@wix/mcp 1.0.93 → 1.0.95

package/build/dts/wixel/wixel-session-tools.js

@@ -5,12 +5,15 @@ import { getWidgetHtml } from '../widget-manifest.js';
 import { RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
 import { WIXEL_WIDGET_URI, WIXEL_MCP_CSP } from './constants.js';
 import { getStylePresetsByIds, getAsset, queryAssets } from './api.js';
-import { startWixelSession, sendWixelSessionMessage, listWixelSessionEvents, getWixelPendingQuestion, getWixelSessionActivity, getWixelSessionProjectId } from './external-agent-api.js';
+import { getWixelTask, isTerminalTaskState, sendWixelMessage, summarizeTask, WixelA2AError, WIXEL_MESSAGE_MAX_LENGTH } from './wixel-a2a-client.js';
+import { getWixelPendingQuestion, getWixelSessionActivity, getWixelSessionProjectId } from './wixel-session-entries.js';
 import { registerAppTool } from '@modelcontextprotocol/ext-apps/server';
-import { isValidUuid } from './utils.js';
-// MCP tools backed by the wixel-agent-service external-session API
-// (WIXEL_AGENT_EXTERNAL_API handoff): start_wixel_session / SendMessage /
-// ListEvents with cursor-based inbox polling.
+// MCP tools backed by the Wixel agent's A2A endpoint: send_wixel_message
+// (SendMessage) starts a conversation or adds a turn and returns the turn as a
+// task; get_wixel_task (GetTask) reports it. A conversation is a contextId, a
+// turn a taskId — both opaque. A question the agent parks on is read from the
+// session's entries log (wixel-session-entries.ts), which a task does not
+// carry.
 const TOOL_META = {
     ui: { visibility: ['app', 'model'] }
 };
@@ -80,25 +83,6 @@ export function collectDecks(projectAssets, deckIds) {
     }
     return decks;
 }
-/**
- * A reply that ends by asking the user something (a plan to approve, a
- * choice to make) is not a delivery even when it links media — an animation
- * plan links the source image it will animate. Asset-id markers ("Asset
- * ready for … (id)") only appear on real deliveries; media URLs alone need
- * this check.
- */
-function isQuestionReply(text) {
-    return /\?\s*$/.test(text.trim());
-}
-// Image/video replies often carry no asset-id marker — just the media URL in
-// the text: a wixstatic file, a wixmp render (img-wixmp-*/wixmp-* hosts), or a
-// links.wixel.com short link that redirects to one. Those links are the
-// deliverable too. Keep the hosts in step with parseWixelMediaUrl, or a URL
-// the resolver would accept never gets extracted in the first place.
-function extractMediaUrls(text) {
-    const matches = text.match(/https:\/\/(?:(?:static|video)\.wixstatic\.com|[a-z0-9-]+\.wixmp\.com|links\.wixel\.com\/link)\/[^\s)\]"'<>]+/g);
-    return matches ? Array.from(new Set(matches)) : [];
-}
 /**
  * Run `fn` over `items` with at most `limit` in flight. `assetIds`/`mediaUrls`
  * arrive from the model, so an unbounded Promise.all would let one call fan out
@@ -202,84 +186,59 @@ async function resolveWixelShortLink(url) {
     }
     return null;
 }
-// Terminal replies carry the created asset ids two ways: an HTML comment,
-// <!-- wixel-agent-assets:["<assetId>", ...] -->, or named inline as
-// `Asset ready for "<name>" (<assetId>)`. Both forms matter — without an id
-// there is no entity to resolve, and a deck falls back to the one URL the
-// reply does carry, which is its PDF export rather than its page images.
-// Anchored on that phrasing and UUID-checked so a turnId can't slip in.
-export function extractAssetIds(text) {
-    const ids = [];
-    const marker = text.match(/wixel-agent-assets:(\[[^\]]*\])/);
-    if (marker) {
-        try {
-            const parsed = JSON.parse(marker[1]);
-            if (Array.isArray(parsed)) {
-                ids.push(...parsed.filter((id) => typeof id === 'string'));
-            }
-        }
-        catch (error) {
-            console.warn('[Wixel] unparsable asset marker', error.message);
-        }
-    }
-    for (const match of text.matchAll(/Asset ready for\b[^\n]*?\(\s*([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})\s*\)/gi)) {
-        ids.push(match[1]);
-    }
-    return Array.from(new Set(ids.filter(isValidUuid)));
-}
 const QUESTION_TOOL_META = {
     ui: {
         resourceUri: WIXEL_WIDGET_URI,
         visibility: ['app', 'model']
     }
 };
-const MAX_LIVE_CARD_HANDLES = 500;
+const MAX_LIVE_CARD_CONTEXTS = 500;
 // A card that never reported done (unmounted, tab closed, timed out) must not
-// lock the agent out of the handle forever.
+// lock the agent out of the conversation forever.
 const LIVE_CARD_TTL_MS = 30 * 60 * 1000;
 export function createLiveCardRegistry() {
     const records = new Map();
-    const get = (handle) => records.get(handle);
-    const forHandle = (handle) => {
-        let record = records.get(handle);
+    const get = (contextId) => records.get(contextId);
+    const forContext = (contextId) => {
+        let record = records.get(contextId);
         if (!record) {
-            if (records.size >= MAX_LIVE_CARD_HANDLES) {
+            if (records.size >= MAX_LIVE_CARD_CONTEXTS) {
                 const oldest = records.keys().next().value;
                 if (oldest !== undefined)
                     records.delete(oldest);
             }
             record = {
-                turns: new Map(),
-                finishedTurns: new Set(),
+                tasks: new Map(),
+                finishedTasks: new Set(),
                 shownAssets: new Set(),
-                lastSentTurn: null
+                lastSentTask: null
             };
-            records.set(handle, record);
+            records.set(contextId, record);
         }
         return record;
     };
     /**
-     * Whether the turn the agent last sent is being followed by a live card
-     * that has not finished. Only the card's own polls mark a turn finished,
-     * so when the card is gone this also consults the inbox: a terminal event
-     * for the turn ends the card's claim, as does the TTL.
+     * Whether the task last sent in the conversation is being followed by a
+     * live card that has not finished. Only the card's own polls mark a task
+     * finished, so when the card is gone this also asks for the task: a
+     * terminal state ends the card's claim, as does the TTL.
      */
-    const isActive = async (handle, params) => {
-        const record = records.get(handle);
-        const turnId = record?.lastSentTurn;
-        if (!record || !turnId)
+    const isActive = async (contextId, isTerminal) => {
+        const record = records.get(contextId);
+        const taskId = record?.lastSentTask;
+        if (!record || !taskId)
             return false;
-        const renderedAt = record.turns.get(turnId);
-        if (renderedAt === undefined || record.finishedTurns.has(turnId)) {
+        const renderedAt = record.tasks.get(taskId);
+        if (renderedAt === undefined || record.finishedTasks.has(taskId)) {
             return false;
         }
         if (Date.now() - renderedAt > LIVE_CARD_TTL_MS) {
-            record.finishedTurns.add(turnId);
+            record.finishedTasks.add(taskId);
             return false;
         }
         try {
-            if (await hasTerminalEvent({ ...params, handle, turnId })) {
-                record.finishedTurns.add(turnId);
+            if (await isTerminal(taskId)) {
+                record.finishedTasks.add(taskId);
                 return false;
             }
         }
@@ -289,29 +248,78 @@ export function createLiveCardRegistry() {
         }
         return true;
     };
-    return { get, forHandle, isActive };
+    return { get, forContext, isActive };
 }
-// Replays the inbox from the start (explicit cursor, so the agent's remembered
-// cursor never moves) and reports whether the turn has its reply/failed event.
-async function hasTerminalEvent(params) {
-    const inbox = await listWixelSessionEvents({
-        authHeaders: params.authHeaders,
-        conductorOverride: params.conductorOverride,
-        handle: params.handle,
-        metaSiteId: params.metaSiteId,
-        since: '0'
-    });
-    if (inbox.error) {
-        throw new Error(`${inbox.error} (${inbox.code ?? 'no code'})`);
+/**
+ * A terminal check for isActive that reuses a task already fetched in this
+ * call instead of asking for it again.
+ */
+function terminalCheck(base, known) {
+    return async (taskId) => {
+        const task = known && known.id === taskId
+            ? known
+            : await getWixelTask({ ...base, taskId });
+        return isTerminalTaskState(task.status?.state);
+    };
+}
+/**
+ * GetTask for a task the caller names together with its site. The service
+ * already refuses a task outside the caller's own sessions and the site they
+ * were created on; this repeats the site half here, so a task is never shown
+ * under a metaSiteId it does not carry. Answers like the service: not found.
+ */
+async function getSiteTask({ metaSiteId, ...params }) {
+    const task = await getWixelTask(params);
+    const taskSite = summarizeTask(task).metaSiteId;
+    if (taskSite && taskSite !== metaSiteId) {
+        throw new WixelA2AError(404, 'Unknown task id');
     }
-    return (inbox.events ?? []).some((event) => event.turnId === params.turnId &&
-        (event.type === 'reply' || event.type === 'failed'));
+    return task;
 }
+/** A tool result for an error the Wixel agent's A2aService answered with. */
+function a2aErrorResult(prefix, error) {
+    return {
+        isError: true,
+        content: [
+            {
+                type: 'text',
+                text: `${prefix}: ${error.message}${error.status ? ` (HTTP ${error.status})` : ''}`
+            }
+        ],
+        structuredContent: {
+            success: false,
+            error: error.message,
+            status: error.status
+        }
+    };
+}
+const CONTEXT_MISMATCH_TEXT = 'contextId does not belong to taskId. Pass the contextId and taskId exactly as send_wixel_message returned them.';
+function contextMismatchResult() {
+    return {
+        isError: true,
+        content: [{ type: 'text', text: CONTEXT_MISMATCH_TEXT }],
+        structuredContent: { success: false, error: 'contextId mismatch' }
+    };
+}
+const END_TURN_SILENTLY = `End your turn now WITHOUT writing any message — no summary, no "Wixel is working on it", nothing: the card already says it, and a sentence under it is redundant. If your client forces a reply, use at most two words.`;
 /** McpAppsBiProvider builds the widget's BI logger from
  *  widgetPayload.extras.biContext; without it every widget event is dropped. */
 function widgetResultMeta(server) {
     return { widgetPayload: { extras: server.getWidgetExtras() } };
 }
+const taskIdInput = z
+    .string()
+    .min(1)
+    .max(512)
+    .describe('taskId returned by send_wixel_message');
+const contextIdInput = z
+    .string()
+    .min(1)
+    .max(512)
+    .describe('contextId returned by send_wixel_message');
+const metaSiteIdInput = z
+    .string()
+    .describe('metaSiteId returned by send_wixel_message');
 export function addGetWixelPendingQuestionTool(server, authStrategy, options = {}) {
     const liveCards = options.liveCards ?? createLiveCardRegistry();
     const { getSiteAuthHeaders } = authStrategy;
@@ -338,17 +346,16 @@ export function addGetWixelPendingQuestionTool(server, authStrategy, options = {
     });
     registerAppTool(server, 'get_wixel_pending_question', {
         title: 'Get pending Wixel question',
-        description: `Fetch the structured question the Wixel agent asked in its latest turn (outline review, style selection, confirmation, choices).
-Call this after a reply event whenever the reply asks the user something. In widget-capable clients this renders an interactive question widget the user can answer directly; otherwise present the returned questions as text and send the user's answer via send_wixel_message.`,
+        description: `Fetch the structured question the Wixel agent asked in a turn (outline review, style selection, confirmation, choices).
+Call this when get_wixel_task flags a question, or its reply asks the user something. In widget-capable clients this renders an interactive question widget the user can answer directly; otherwise present the returned questions as text and send the user's answer via send_wixel_message.`,
         inputSchema: {
-            handle: z.string().describe('Session handle from start_wixel_session'),
-            metaSiteId: z
-                .string()
-                .describe('Meta site ID from start_wixel_session'),
+            contextId: contextIdInput,
+            taskId: taskIdInput,
+            metaSiteId: metaSiteIdInput,
             questionId: z
                 .string()
                 .optional()
-                .describe('Pass the questionId when list_wixel_events flagged one — it binds the rendered widget to that question and returns null if it is no longer pending.')
+                .describe('Pass the questionId when get_wixel_task flagged one — it binds the rendered widget to that question and returns null if it is no longer pending.')
         },
         annotations: {
             readOnlyHint: true,
@@ -357,31 +364,38 @@ Call this after a reply event whenever the reply asks the user something. In wid
         },
         _meta: QUESTION_TOOL_META
     }, async (args, extra) => {
-        setBi(extra, {
-            siteId: args.metaSiteId,
-            conversationId: args.handle
-        });
+        setBi(extra, { siteId: args.metaSiteId });
         // Resolve auth before the try block so UnauthorizedError propagates to
         // wrapToolCallback with the OAuth re-auth metadata (see auth/index.ts).
         const authHeaders = await getSiteAuthHeaders(args.metaSiteId);
+        const base = {
+            authHeaders,
+            conductorOverride: options.conductorOverride
+        };
         try {
-            // The external API returns handle === sessionId; the internal lookups
-            // verify the id against the caller's own sessions listing and fail
-            // closed if the contract ever diverges (see isSessionVisibleToCaller).
-            let pending = await getWixelPendingQuestion({
-                authHeaders,
-                sessionId: args.handle,
-                conductorOverride: options.conductorOverride
+            // The session is read from the task the agent itself vouches for;
+            // the entries reads verify it against the caller's own sessions
+            // listing as well (see isSessionVisibleToCaller).
+            const task = await getSiteTask({
+                ...base,
+                taskId: args.taskId,
+                metaSiteId: args.metaSiteId
             });
+            if (task.contextId !== args.contextId)
+                return contextMismatchResult();
+            const { sessionId, turnId } = summarizeTask(task);
+            setBi(extra, {
+                siteId: args.metaSiteId,
+                ...(sessionId ? { conversationId: sessionId } : {})
+            });
+            let pending = sessionId
+                ? await getWixelPendingQuestion({ ...base, sessionId, turnId })
+                : null;
             // The live card renders this question inline; a second, standalone
             // question widget would put it in the chat twice.
             if (pending &&
                 options.supportsWidgets?.() === true &&
-                (await liveCards.isActive(args.handle, {
-                    authHeaders,
-                    conductorOverride: options.conductorOverride,
-                    metaSiteId: args.metaSiteId
-                }))) {
+                (await liveCards.isActive(task.contextId, terminalCheck(base, task)))) {
                 console.log('[WixelResponseDump]', JSON.stringify({
                     tool: 'get_wixel_pending_question',
                     args,
@@ -393,7 +407,7 @@ Call this after a reply event whenever the reply asks the user something. In wid
                         {
                             type: 'text',
                             text: `The live result card already shows this question to the user and sends the answer to Wixel itself.
-<agent_instruction>Do NOT present the question and do NOT poll list_wixel_events — the card follows the turn. Do not tell the user to answer either — the card is self-explanatory. End your turn now WITHOUT writing any message — no summary, no "Wixel is working on it", nothing: the card already says it, and a sentence under it is redundant. If your client forces a reply, use at most two words.</agent_instruction>`
+<agent_instruction>Do NOT present the question and do NOT poll get_wixel_task — the card follows the turn. Do not tell the user to answer either — the card is self-explanatory. ${END_TURN_SILENTLY}</agent_instruction>`
                         }
                     ],
                     structuredContent: { success: true, pendingQuestion: null }
@@ -430,18 +444,19 @@ Call this after a reply event whenever the reply asks the user something. In wid
                 .join('\n');
             const responseText = widgetShown
                 ? `An interactive question widget is displayed to the user (questionId: ${pending.toolCallId}):\n${summary}
-<agent_instruction>Do NOT repeat the question content as text — the user answers inside the widget, which sends the answer to Wixel itself. This is NOT a turn-taking situation: the user's widget answer and the generated result arrive ONLY as events to YOU via list_wixel_events — nothing wakes you if you stop, and ending your turn BREAKS the flow (the user's answer would go nowhere and the result would never be delivered).
-Therefore: briefly tell the user to answer in the widget, then keep calling list_wixel_events (handle: "${args.handle}", metaSiteId: "${args.metaSiteId}", waitSeconds: 25) in a continuous loop — the server advances the cursor for you — and do NOT end your turn until a "reply" or "failed" event arrives, however long it takes (the user may think for a while, then generation takes minutes).
-- Empty polls that flag questionId ${pending.toolCallId} mean the user has not answered THIS question yet — do NOT call get_wixel_pending_question again for it, just keep polling.
-- When a reply/failed event arrives: if the response flags a NEW interactive question, call get_wixel_pending_question again (it renders the next widget). Otherwise present the reply to the user as a normal chat message, always including the "Edit in Wixel" link when provided.</agent_instruction>`
+<agent_instruction>Do NOT repeat the question content as text — the user answers inside the widget, which sends the answer to Wixel itself. This is NOT a turn-taking situation: the result of the user's widget answer reaches YOU only through get_wixel_task — nothing wakes you if you stop, and ending your turn BREAKS the flow (the result would never be delivered).
+Therefore: briefly tell the user to answer in the widget, then keep calling get_wixel_task (taskId: "${args.taskId}", metaSiteId: "${args.metaSiteId}", waitSeconds: 25) in a continuous loop, and do NOT end your turn until it reports the turn done, however long it takes (the user may think for a while, then generation takes minutes). If it names a newer taskId (the widget's answer opened a new turn), follow that one.
+- Polls that flag questionId ${pending.toolCallId} mean the user has not answered THIS question yet — do NOT call get_wixel_pending_question again for it, just keep polling.
+- When the turn is done: if the response flags a NEW interactive question, call get_wixel_pending_question again (it renders the next widget). Otherwise present the reply to the user as a normal chat message, always including the "Edit in Wixel" link when provided.</agent_instruction>`
                 : `The Wixel agent asked:\n${summary}
-<agent_instruction>Present the question(s) with their options/content to the user, then send their answer as plain text via send_wixel_message (same handle/metaSiteId) and resume polling list_wixel_events.</agent_instruction>`;
+<agent_instruction>Present the question(s) with their options/content to the user, then send their answer as plain text via send_wixel_message (contextId: "${args.contextId}", metaSiteId: "${args.metaSiteId}") and poll get_wixel_task for the taskId it returns.</agent_instruction>`;
             return {
                 isError: false,
                 content: [{ type: 'text', text: responseText }],
                 structuredContent: {
                     success: true,
-                    handle: args.handle,
+                    contextId: args.contextId,
+                    taskId: args.taskId,
                     metaSiteId: args.metaSiteId,
                     pendingQuestion: pending
                 },
@@ -449,6 +464,9 @@ Therefore: briefly tell the user to answer in the widget, then keep calling list
             };
         }
         catch (error) {
+            if (error instanceof WixelA2AError) {
+                return a2aErrorResult('Could not read the Wixel task', error);
+            }
             rethrowIfUnauthorized(error);
             console.error('❌ Error getting Wixel pending question:', error);
             const errorMessage = error.message;
@@ -460,127 +478,36 @@ Therefore: briefly tell the user to answer in the widget, then keep calling list
         }
     });
 }
-export function addStartWixelSessionTool(server, authStrategy, options = {}) {
-    const { getAccountAuthHeaders, getSiteAuthHeaders } = authStrategy;
-    registerAppTool(server, 'start_wixel_session', {
-        title: 'Start Wixel session',
-        description: `Start (or resume) a session with Wixel — Wix's AI creative studio that GENERATES visual assets from text prompts: images, logos, slide decks / presentations, videos, documents, and event invitations. Use this flow for any "create/generate an image / logo / slides / video" request. It is NOT a website builder.
-Call this ONCE per conversation and persist the returned handle + metaSiteId (Wixel's project identifiers) — they are required by send_wixel_message and list_wixel_events.
-Without arguments Wixel provisions a new project and session. Pass metaSiteId to reuse an existing project; pass sessionId + metaSiteId to resume a session created by this API.`,
-        inputSchema: {
-            sessionId: z
-                .string()
-                .optional()
-                .describe('Existing session ID to resume (requires metaSiteId as well)'),
-            metaSiteId: z
-                .string()
-                .optional()
-                .describe('Existing meta site ID to reuse its project'),
-            externalId: z
-                .string()
-                .optional()
-                .describe('Stable identifier of the caller conversation (for diagnostics)'),
-            workspace: z
-                .enum(['UNKNOWN', 'BRAND'])
-                .optional()
-                .describe('Workspace to provision; omit for the default')
-        },
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: false,
-            openWorldHint: false
-        },
-        _meta: TOOL_META
-    }, async (args, extra) => {
-        // Both are absent on a fresh session; refined again after the call.
-        setBi(extra, {
-            ...(args.metaSiteId ? { siteId: args.metaSiteId } : {}),
-            ...(args.sessionId ? { conversationId: args.sessionId } : {})
-        });
-        if (args.sessionId && !args.metaSiteId) {
-            return {
-                isError: true,
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Invalid input: resuming a session (sessionId) also requires the metaSiteId returned by the original start_wixel_session call.'
-                    }
-                ],
-                structuredContent: {
-                    success: false,
-                    error: 'sessionId requires metaSiteId'
-                }
-            };
-        }
-        const authHeaders = args.metaSiteId
-            ? await getSiteAuthHeaders(args.metaSiteId)
-            : await getAccountAuthHeaders();
-        try {
-            const session = await startWixelSession({
-                authHeaders,
-                conductorOverride: options.conductorOverride,
-                sessionId: args.sessionId,
-                metaSiteId: args.metaSiteId,
-                externalId: args.externalId,
-                workspace: args.workspace
-            });
-            setBi(extra, {
-                siteId: session.metaSiteId ?? args.metaSiteId,
-                conversationId: session.handle ?? args.sessionId
-            });
-            console.log('[WixelResponseDump]', JSON.stringify({ tool: 'start_wixel_session', args, session }));
-            return {
-                isError: false,
-                content: [
-                    {
-                        type: 'text',
-                        text: `Wixel session ${session.status ?? 'started'} — handle: ${session.handle}, metaSiteId: ${session.metaSiteId}.
-<agent_instruction>Persist handle and metaSiteId for this conversation. Send prompts with send_wixel_message, then poll list_wixel_events (advancing the cursor) until a "reply" or "failed" event arrives for the returned turnId.</agent_instruction>`
-                    }
-                ],
-                structuredContent: {
-                    success: true,
-                    handle: session.handle,
-                    sessionId: session.sessionId,
-                    metaSiteId: session.metaSiteId,
-                    status: session.status,
-                    expiresAt: session.expiresAt ?? null
-                }
-            };
-        }
-        catch (error) {
-            rethrowIfUnauthorized(error);
-            console.error('❌ Error starting Wixel session:', error);
-            const errorMessage = error.message;
-            return {
-                isError: true,
-                content: [{ type: 'text', text: errorMessage }],
-                structuredContent: { success: false, error: errorMessage }
-            };
-        }
-    });
-}
 export function addSendWixelMessageTool(server, authStrategy, options = {}) {
     const liveCards = options.liveCards ?? createLiveCardRegistry();
-    const { getSiteAuthHeaders } = authStrategy;
+    const { getAccountAuthHeaders, getSiteAuthHeaders } = authStrategy;
     registerAppTool(server, 'send_wixel_message', {
         title: 'Send Wixel message',
-        description: `Send a generation or refinement prompt to a Wixel session (started with start_wixel_session) — e.g. "create an image of a pirate dog", "a 10-slide pitch deck for my bakery", "make the logo blue". The turn runs asynchronously — a successful response only means the turn was ACCEPTED and returns a turnId.
-Obtain the agent's answer (including links to the generated assets) by polling list_wixel_events until a "reply" or "failed" event for that turnId appears.
+        description: `Send a request to Wixel — Wix's AI creative studio that GENERATES visual assets from text prompts: images, logos, slide decks / presentations, videos, documents, and event invitations. Use it for any "create/generate an image / logo / slides / video" request, and for refinements ("make the logo blue"). It is NOT a website builder.
+The first call starts a conversation: omit contextId (pass metaSiteId only to reuse an existing Wixel project). It returns contextId, taskId and metaSiteId — persist contextId and pass only contextId on every later message of the conversation (it is already bound to its site).
+The turn runs asynchronously — the response only means it was ACCEPTED. Obtain the agent's answer (including links to the generated assets) with get_wixel_task for the returned taskId.
 Send the user's request as THEY phrased it. Do NOT add creative direction they did not give — style, palette, mood, tone, audience, aspect ratio, slide count or slide topics. Wixel asks the user about those itself, and widget-capable clients render the question as an interactive widget (get_wixel_pending_question), so details you invent silently overwrite the choices the user was about to make. Rephrasing for clarity or translating is fine; filling in the blanks is not.`,
         inputSchema: {
-            handle: z.string().describe('Session handle from start_wixel_session'),
-            metaSiteId: z
-                .string()
-                .describe('Meta site ID from start_wixel_session'),
             text: z
                 .string()
-                .max(32000)
+                .min(1)
+                .max(WIXEL_MESSAGE_MAX_LENGTH)
                 .describe("The user's request in their own words — do not add style, palette, audience or content details they did not give"),
-            transactionId: z
+            contextId: z
+                .string()
+                .min(1)
+                .max(512)
+                .optional()
+                .describe('The conversation, as a previous send_wixel_message returned it. Omit to start a new conversation.'),
+            metaSiteId: z
+                .string()
+                .optional()
+                .describe('First message only: an existing meta site ID whose Wixel project the new conversation reuses. Ignored with contextId.'),
+            externalId: z
                 .string()
+                .max(256)
                 .optional()
-                .describe('Optional caller correlation ID echoed in terminal events')
+                .describe('Stable identifier of the caller conversation (for diagnostics)')
         },
         annotations: {
             readOnlyHint: false,
@@ -589,72 +516,74 @@ Send the user's request as THEY phrased it. Do NOT add creative direction they d
         },
         _meta: TOOL_META
     }, async (args, extra) => {
-        setBi(extra, {
-            siteId: args.metaSiteId,
-            conversationId: args.handle
-        });
-        const authHeaders = await getSiteAuthHeaders(args.metaSiteId);
+        // A later message names only its conversation: the agent reads the site
+        // from the contextId and checks it against the caller's own sites, so
+        // the account identity is enough. A site identity is only needed when a
+        // first message reuses an existing site's project.
+        const reuseSite = args.contextId ? undefined : args.metaSiteId;
+        setBi(extra, reuseSite ? { siteId: reuseSite } : {});
+        const authHeaders = reuseSite
+            ? await getSiteAuthHeaders(reuseSite)
+            : await getAccountAuthHeaders();
         try {
             // The user's text goes through as typed — nothing is appended. An
             // earlier hint here asked Wixel to stop and ask about style/palette
             // whenever a request left them open, which is why MCP users got
             // questions the Wixel app never asks. Wixel's own flows (a deck's
             // outline and style review) still ask, and the live card renders them.
-            const text = args.text;
-            const result = await sendWixelSessionMessage({
+            const task = await sendWixelMessage({
                 authHeaders,
                 conductorOverride: options.conductorOverride,
-                handle: args.handle,
-                metaSiteId: args.metaSiteId,
-                text,
-                transactionId: args.transactionId
+                text: args.text,
+                contextId: args.contextId,
+                metaSiteId: reuseSite,
+                externalId: args.externalId
+            });
+            const summary = summarizeTask(task);
+            const metaSiteId = summary.metaSiteId ?? reuseSite ?? null;
+            setBi(extra, {
+                ...(metaSiteId ? { siteId: metaSiteId } : {}),
+                ...(summary.sessionId ? { conversationId: summary.sessionId } : {})
             });
             console.log('[WixelResponseDump]', JSON.stringify({
                 tool: 'send_wixel_message',
-                args: { ...args, text: text.slice(0, 400) },
-                result
+                args: { ...args, text: args.text.slice(0, 400) },
+                task: {
+                    id: task.id,
+                    contextId: task.contextId,
+                    state: summary.state,
+                    metadata: task.metadata
+                }
             }));
-            if (!result.ok) {
-                return {
-                    isError: true,
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Wixel rejected the message: ${result.error ?? 'unknown error'} (${result.code ?? 'no code'})`
-                        }
-                    ],
-                    structuredContent: {
-                        success: false,
-                        error: result.error,
-                        code: result.code
-                    }
-                };
-            }
-            if (result.turnId) {
-                liveCards.forHandle(args.handle).lastSentTurn = result.turnId;
-            }
+            liveCards.forContext(task.contextId).lastSentTask = task.id;
+            const steeredNote = summary.steered
+                ? "\nA turn was already running, so the message was added to it: this is that turn's task."
+                : '';
             // Widget clients get a live result card that follows the turn itself
             // (progress, questions, final asset), so the agent renders it once
             // and stops — no polling loop of tool calls in the conversation.
             const instruction = options.supportsWidgets?.()
-                ? `<agent_instruction>Now call get_wixel_asset_result with handle: "${args.handle}", metaSiteId: "${args.metaSiteId}", turnId: "${result.turnId}", prompt: <the user's request as they phrased it>. It renders a live result card that shows progress, asks the user any question Wixel has, and displays the final asset. Then end your turn — do NOT poll list_wixel_events and do NOT call get_wixel_pending_question, and do NOT write a message after the card (it explains itself).</agent_instruction>`
-                : `<agent_instruction>Poll list_wixel_events (handle: "${args.handle}", metaSiteId: "${args.metaSiteId}", waitSeconds: 25, advancing the returned cursor) until an event with turnId "${result.turnId}" has type "reply" or "failed". Turns can take minutes for generation tasks — keep polling.
-After a reply that asks the user something (review an outline, pick a style, confirm), call get_wixel_pending_question (same handle/metaSiteId) and follow its response instruction.</agent_instruction>`;
+                ? `<agent_instruction>Now call get_wixel_asset_result with contextId: "${task.contextId}", taskId: "${task.id}", metaSiteId: "${metaSiteId}", prompt: <the user's request as they phrased it>. It renders a live result card that shows progress, asks the user any question Wixel has, and displays the final asset. Then end your turn — do NOT poll get_wixel_task and do NOT call get_wixel_pending_question, and do NOT write a message after the card (it explains itself).</agent_instruction>`
+                : `<agent_instruction>Poll get_wixel_task (taskId: "${task.id}", metaSiteId: "${metaSiteId}", waitSeconds: 25) until it reports the turn done. Turns can take minutes for generation tasks — keep polling.
+If it flags an interactive question, call get_wixel_pending_question (contextId: "${task.contextId}", taskId: "${task.id}", metaSiteId: "${metaSiteId}") and follow its response instruction.</agent_instruction>`;
             const structuredContent = {
                 success: true,
-                sessionId: result.sessionId,
-                turnId: result.turnId,
-                transactionId: result.transactionId ?? null
+                contextId: task.contextId,
+                taskId: task.id,
+                metaSiteId,
+                sessionId: summary.sessionId,
+                state: summary.state,
+                steered: summary.steered
             };
             return {
                 isError: false,
                 content: [
                     {
                         type: 'text',
-                        text: `Turn accepted — turnId: ${result.turnId}.
+                        text: `Turn accepted — contextId: ${task.contextId}, taskId: ${task.id}, metaSiteId: ${metaSiteId}.${steeredNote}
 ${instruction}`
                     },
-                    // The widgets send answers through this tool and need the turnId
+                    // The widgets send answers through this tool and need the taskId
                     // back; hosts that drop structuredContent get it from this item.
                     { type: 'text', text: JSON.stringify(structuredContent) }
                 ],
@@ -662,6 +591,9 @@ ${instruction}`
             };
         }
         catch (error) {
+            if (error instanceof WixelA2AError) {
+                return a2aErrorResult('Wixel rejected the message', error);
+            }
             rethrowIfUnauthorized(error);
             console.error('❌ Error sending Wixel message:', error);
             const errorMessage = error.message;
@@ -673,37 +605,24 @@ ${instruction}`
         }
     });
 }
-export function addListWixelEventsTool(server, authStrategy, options = {}) {
+const LONG_POLL_INTERVAL_MS = 2500;
+const LONG_POLL_MAX_SECONDS = 25;
+export function addGetWixelTaskTool(server, authStrategy, options = {}) {
     const liveCards = options.liveCards ?? createLiveCardRegistry();
     const { getSiteAuthHeaders } = authStrategy;
-    // Models routinely forget to thread the cursor through poll loops, which
-    // makes them re-read old replies and misjudge the session state. Remember
-    // the last served cursor per handle (per MCP session) and use it whenever
-    // "since" is omitted.
-    const lastCursorByHandle = new Map();
-    registerAppTool(server, 'list_wixel_events', {
-        title: 'List Wixel events',
-        description: `Read durable turn events from a Wixel Agent session inbox. Pass the cursor returned by the previous call as "since" to only receive newer events.
-Event types: "reply" (the agent's answer), "failed" (the turn failed), and "user" (only with historyMode FULL). Poll until the awaited turnId gets a reply/failed event.`,
+    registerAppTool(server, 'get_wixel_task', {
+        title: 'Get Wixel task',
+        description: `Report a Wixel turn (a task returned by send_wixel_message): still working, parked on a question for the user, done with the agent's reply and the generated assets, or failed.
+Poll it with waitSeconds: 25 until it reports the turn done.`,
         inputSchema: {
-            handle: z.string().describe('Session handle from start_wixel_session'),
-            metaSiteId: z
-                .string()
-                .describe('Meta site ID from start_wixel_session'),
-            since: z
-                .string()
-                .optional()
-                .describe('Cursor returned by the previous list_wixel_events call. May be omitted — the server remembers the last cursor it served for this handle and continues from there.'),
-            historyMode: z
-                .enum(['REPLIES_ONLY', 'FULL'])
-                .optional()
-                .describe('REPLIES_ONLY (default) returns terminal events only; FULL also includes echoed user messages'),
+            taskId: taskIdInput,
+            metaSiteId: metaSiteIdInput,
             waitSeconds: z
                 .number()
                 .min(0)
-                .max(25)
+                .max(LONG_POLL_MAX_SECONDS)
                 .optional()
-                .describe('Long-poll: when no new events are available, hold the request up to this many seconds until one arrives. Recommended: 25 while waiting on generation or on a widget answer.')
+                .describe('Long-poll: while the turn is still working, hold the request up to this many seconds until it ends. Recommended: 25 while waiting on generation or on a widget answer.')
         },
         annotations: {
             readOnlyHint: true,
@@ -712,39 +631,38 @@ Event types: "reply" (the agent's answer), "failed" (the turn failed), and "user
         },
         _meta: TOOL_META
     }, async (args, extra) => {
-        setBi(extra, {
-            siteId: args.metaSiteId,
-            conversationId: args.handle
-        });
+        setBi(extra, { siteId: args.metaSiteId });
         const authHeaders = await getSiteAuthHeaders(args.metaSiteId);
+        const base = {
+            authHeaders,
+            conductorOverride: options.conductorOverride
+        };
         try {
-            const since = args.since ?? lastCursorByHandle.get(args.handle);
-            const fetchEvents = () => listWixelSessionEvents({
-                authHeaders,
-                conductorOverride: options.conductorOverride,
-                handle: args.handle,
-                metaSiteId: args.metaSiteId,
-                since,
-                historyMode: args.historyMode
+            const fetchTask = () => getSiteTask({
+                ...base,
+                taskId: args.taskId,
+                metaSiteId: args.metaSiteId
             });
-            // A live result card is following the last turn: the agent has
-            // nothing to do here, and text instructions alone don't stop its
-            // polling loop — so refuse the call (no fetch, cursor untouched).
-            // The tool works again once the turn has ended (the card saw it, or
-            // the inbox says so when the card is gone).
+            let task = await fetchTask();
+            let summary = summarizeTask(task);
+            setBi(extra, {
+                siteId: args.metaSiteId,
+                ...(summary.sessionId ? { conversationId: summary.sessionId } : {})
+            });
+            // A live result card is following the conversation's latest turn:
+            // the agent has nothing to do here, and text instructions alone don't
+            // stop its polling loop — so refuse the call. The tool works again
+            // once that turn has ended (the card saw it, or the task says so
+            // when the card is gone).
             if (options.supportsWidgets?.() === true &&
-                (await liveCards.isActive(args.handle, {
-                    authHeaders,
-                    conductorOverride: options.conductorOverride,
-                    metaSiteId: args.metaSiteId
-                }))) {
-                console.log('[WixelResponseDump]', JSON.stringify({ tool: 'list_wixel_events', args, refused: true }));
+                (await liveCards.isActive(task.contextId, terminalCheck(base, task)))) {
+                console.log('[WixelResponseDump]', JSON.stringify({ tool: 'get_wixel_task', args, refused: true }));
                 return {
                     isError: true,
                     content: [
                         {
                             type: 'text',
-                            text: `Not needed: the live result card is following this generation and will display progress, any question, and the final result by itself. This is not a failure — there is nothing to wait for here. Do NOT call list_wixel_events, get_wixel_pending_question or get_wixel_asset_result again for this generation. End your turn now WITHOUT writing any message — no summary, no "Wixel is working on it", nothing: the card already says it, and a sentence under it is redundant. If your client forces a reply, use at most two words.`
+                            text: `Not needed: the live result card is following this generation and will display progress, any question, and the final result by itself. This is not a failure — there is nothing to wait for here. Do NOT call get_wixel_task, get_wixel_pending_question or get_wixel_asset_result again for this generation. ${END_TURN_SILENTLY}`
                         }
                     ],
                     structuredContent: {
@@ -754,181 +672,41 @@ Event types: "reply" (the agent's answer), "failed" (the turn failed), and "user
                     }
                 };
             }
-            let result = await fetchEvents();
-            // Long-poll: hold the request while the inbox is empty so callers can
+            // Long-poll: hold the request while the turn works so callers can
             // wait on slow turns (generation, widget answers) without hammering.
-            const waitDeadline = Date.now() + Math.min(Math.max(args.waitSeconds ?? 0, 0), 25) * 1000;
-            while (!result.error &&
-                (result.events ?? []).length === 0 &&
-                Date.now() + 2500 <= waitDeadline) {
-                await new Promise((resolve) => setTimeout(resolve, 2500));
-                result = await fetchEvents();
-            }
-            console.log('[WixelResponseDump]', JSON.stringify({ tool: 'list_wixel_events', args, result }));
-            if (result.error) {
-                return {
-                    isError: true,
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Failed to list events: ${result.error} (${result.code ?? 'no code'})`
-                        }
-                    ],
-                    structuredContent: {
-                        success: false,
-                        error: result.error,
-                        code: result.code
-                    }
-                };
-            }
-            const events = result.events ?? [];
-            if (result.cursor) {
-                lastCursorByHandle.set(args.handle, result.cursor);
+            const waitDeadline = Date.now() +
+                Math.min(Math.max(args.waitSeconds ?? 0, 0), LONG_POLL_MAX_SECONDS) *
+                    1000;
+            while (!summary.done &&
+                Date.now() + LONG_POLL_INTERVAL_MS <= waitDeadline) {
+                await new Promise((resolve) => setTimeout(resolve, LONG_POLL_INTERVAL_MS));
+                task = await fetchTask();
+                summary = summarizeTask(task);
             }
-            // Check whether the turn is parked on an interactive question
-            // (ask_user is intercepted on external sessions but its structured
-            // payload is persisted) so clients render it as a widget. This must
-            // also run on EMPTY polls: custom_widget questions park the turn
-            // without emitting a reply event, so the inbox stays empty forever.
-            let questionInstruction = '';
-            let pendingQuestion = null;
-            let turnInProgress = false;
-            let editorUrl = null;
-            // A reply that references created assets IS the deliverable — the
-            // flow is complete, so any parked follow-up question (e.g. "pick a
-            // new style?") must not spawn another widget.
-            let deliveredAssets = false;
-            let deliveredAssetIds = [];
-            let deliveredMediaUrls = [];
-            const hasReply = events.some((event) => event.type === 'reply');
-            if (hasReply) {
-                // Resolve an "edit in Wixel" link once the reply references created
-                // assets: the session is bound to its Wixel project, which is the
-                // editor deep-link target. Some replies carry asset-id markers,
-                // others just embed the media URL — both count as delivered.
-                const replyTexts = events
-                    .filter((event) => event.type === 'reply' && event.text)
-                    .map((event) => event.text);
-                deliveredAssetIds = replyTexts.flatMap(extractAssetIds);
-                // Same rule as the live card: a reply that asks the user something
-                // (e.g. an animation plan linking its source image) delivers
-                // nothing by its media URLs alone.
-                deliveredMediaUrls = replyTexts
-                    .filter((text) => !isQuestionReply(text))
-                    .flatMap(extractMediaUrls);
-                if (deliveredAssetIds.length || deliveredMediaUrls.length) {
-                    deliveredAssets = true;
-                    // Delivered by a turn a live card follows: the card shows them,
-                    // so a get_wixel_asset_result for these ids is a duplicate. Only
-                    // that turn's ids — a batch may also carry a turn no card follows.
-                    const record = liveCards.get(args.handle);
-                    if (record) {
-                        events
-                            .filter((event) => event.type === 'reply' &&
-                            !!event.text &&
-                            !!event.turnId &&
-                            record.turns.has(event.turnId))
-                            .flatMap((event) => [
-                            ...extractAssetIds(event.text).slice(0, MAX_RESULT_ITEMS),
-                            ...extractMediaUrls(event.text).slice(0, MAX_RESULT_ITEMS)
-                        ])
-                            .forEach((item) => record.shownAssets.add(item));
-                    }
-                    try {
-                        const projectId = await getWixelSessionProjectId({
-                            authHeaders,
-                            conductorOverride: options.conductorOverride,
-                            sessionId: args.handle
-                        });
-                        if (projectId) {
-                            editorUrl = buildWixelEditorUrl(args.metaSiteId, projectId);
-                        }
-                    }
-                    catch (projectError) {
-                        console.warn('[Wixel] editor link resolution failed:', projectError.message);
-                    }
-                }
-            }
-            if (hasReply || events.length === 0) {
-                try {
-                    if (hasReply) {
-                        if (!deliveredAssets) {
-                            pendingQuestion = await getWixelPendingQuestion({
-                                authHeaders,
-                                conductorOverride: options.conductorOverride,
-                                sessionId: args.handle
-                            });
-                        }
-                    }
-                    else {
-                        // On an empty poll only a parked ask_user counts — a question
-                        // already handled (policy fallback or answered in the Wixel UI)
-                        // must not resurface while the turn keeps generating. The same
-                        // entries read also tells whether a turn is actively running,
-                        // so the caller knows to keep polling rather than turn to the
-                        // user.
-                        const activity = await getWixelSessionActivity({
-                            authHeaders,
-                            conductorOverride: options.conductorOverride,
-                            sessionId: args.handle
-                        });
-                        pendingQuestion = activity.parkedQuestion;
-                        turnInProgress = activity.turnInProgress;
-                    }
-                }
-                catch (questionError) {
-                    console.warn('[Wixel] pending question fetch failed:', questionError.message);
-                }
-                if (pendingQuestion) {
-                    questionInstruction = `
-IMPORTANT: the agent is asking the user an interactive question (${pendingQuestion.questions
-                        .map((question) => question.kind)
-                        .join(', ')}; questionId: ${pendingQuestion.toolCallId}). If you have NOT yet displayed this questionId, you MUST now call get_wixel_pending_question (handle: "${args.handle}", metaSiteId: "${args.metaSiteId}", questionId: "${pendingQuestion.toolCallId}") and follow its response instruction BEFORE responding to the user — do not present the question yourself. If you already displayed this questionId, the user simply hasn't answered it yet — do NOT end your turn (the answer arrives only as an event to you; stopping breaks the flow): keep polling list_wixel_events (waitSeconds: 25) without re-calling get_wixel_pending_question.`;
-                }
-            }
-            const summary = events.length
-                ? events
-                    .map((event) => `[${event.type}] turnId: ${event.turnId ?? '-'}${event.text ? ` — ${event.text}` : ''}`)
-                    .join('\n')
-                : pendingQuestion
-                    ? 'The turn is parked on an interactive question awaiting the user.'
-                    : turnInProgress
-                        ? 'No new events yet — Wixel is actively working on the current turn.'
-                        : 'No new events yet — call list_wixel_events again with the same cursor.';
-            // An empty poll while a turn is generating must not read as "waiting
-            // on the user" — the caller's next step is to keep polling, nothing
-            // else.
-            const workingInstruction = !events.length && !pendingQuestion && turnInProgress
-                ? `
-<agent_instruction>Wixel is actively generating — the user does NOT need to do anything. Do NOT end your turn and do NOT ask the user for input: call list_wixel_events again (handle: "${args.handle}", metaSiteId: "${args.metaSiteId}", same cursor, waitSeconds: 25) and repeat until a "reply" or "failed" event arrives, however many polls it takes.</agent_instruction>`
-                : '';
-            const editorLine = deliveredAssets
-                ? `${editorUrl ? `\nEdit in Wixel: ${editorUrl}` : ''}\n<agent_instruction>The asset is READY — this reply is the final deliverable. You MUST now call get_wixel_asset_result with EXACTLY these arguments: handle: "${args.handle}", metaSiteId: "${args.metaSiteId}", assetIds: ${JSON.stringify(deliveredAssetIds)}, mediaUrls: ${JSON.stringify(deliveredMediaUrls)}, prompt: <the user's original request>. In widget-capable clients it renders the result card (preview + edit/download actions); otherwise present the reply as text${editorUrl ? ' and ALWAYS include the Edit in Wixel link' : ''}. Do NOT call get_wixel_pending_question now — if the reply offers optional follow-ups (restyle, edits), mention them as text.</agent_instruction>`
-                : '';
-            return {
-                isError: false,
-                content: [
-                    {
-                        type: 'text',
-                        text: `${summary}\ncursor: ${result.cursor}${editorLine}${questionInstruction}${workingInstruction}`
-                    }
-                ],
-                structuredContent: {
-                    success: true,
-                    events,
-                    cursor: result.cursor,
-                    hasPendingQuestion: !!pendingQuestion,
-                    pendingQuestionId: pendingQuestion?.toolCallId ?? null,
-                    turnInProgress,
-                    editorUrl,
-                    assetIds: deliveredAssetIds,
-                    mediaUrls: deliveredMediaUrls
-                }
-            };
+            const result = await describeTask({
+                base,
+                task,
+                summary,
+                liveCards,
+                metaSiteId: args.metaSiteId
+            });
+            console.log('[WixelResponseDump]', JSON.stringify({
+                tool: 'get_wixel_task',
+                args,
+                state: summary.state,
+                replyText: summary.replyText,
+                assetIds: summary.assetIds,
+                mediaUrls: summary.mediaUrls,
+                pendingQuestionId: result.structuredContent.pendingQuestionId
+            }).slice(0, 30000));
+            return result;
         }
         catch (error) {
+            if (error instanceof WixelA2AError) {
+                return a2aErrorResult('Could not read the Wixel task', error);
+            }
             rethrowIfUnauthorized(error);
-            console.error('❌ Error listing Wixel events:', error);
+            console.error('❌ Error getting Wixel task:', error);
             const errorMessage = error.message;
             return {
                 isError: true,
@@ -938,6 +716,125 @@ IMPORTANT: the agent is asking the user an interactive question (${pendingQuesti
         }
     });
 }
+/** get_wixel_task's answer for a task it has read. */
+async function describeTask({ base, task, summary, liveCards, metaSiteId }) {
+    const { taskId, contextId, sessionId } = summary;
+    const ids = `contextId: "${contextId}", taskId: "${taskId}", metaSiteId: "${metaSiteId}"`;
+    const failed = summary.done && summary.state !== 'TASK_STATE_COMPLETED';
+    // A reply that names assets or links media IS the deliverable — the flow
+    // is complete, so any follow-up question (e.g. "pick a new style?") must
+    // not spawn another widget.
+    const delivered = summary.state === 'TASK_STATE_COMPLETED' &&
+        (summary.assetIds.length > 0 || summary.mediaUrls.length > 0);
+    let editorUrl = null;
+    if (delivered) {
+        // Delivered by a turn a live card follows: the card shows them, so a
+        // get_wixel_asset_result for these ids is a duplicate.
+        const record = liveCards.get(task.contextId);
+        if (record?.tasks.has(task.id)) {
+            [
+                ...summary.assetIds.slice(0, MAX_RESULT_ITEMS),
+                ...summary.mediaUrls.slice(0, MAX_RESULT_ITEMS)
+            ].forEach((item) => record.shownAssets.add(item));
+        }
+        // The session is bound to its Wixel project, which is the editor
+        // deep-link target.
+        try {
+            const projectId = sessionId
+                ? await getWixelSessionProjectId({ ...base, sessionId })
+                : null;
+            if (projectId)
+                editorUrl = buildWixelEditorUrl(metaSiteId, projectId);
+        }
+        catch (projectError) {
+            console.warn('[Wixel] editor link resolution failed:', projectError.message);
+        }
+    }
+    // A question worth surfacing: on a working turn only a parked ask_user
+    // counts (a question already handled — policy fallback or answered in the
+    // Wixel UI — must not resurface while the turn keeps generating); on a
+    // completed turn without a delivery, the question the reply restates.
+    let pendingQuestion = null;
+    let turnInProgress = false;
+    if (sessionId && !failed && !delivered) {
+        try {
+            if (summary.done) {
+                pendingQuestion = await getWixelPendingQuestion({
+                    ...base,
+                    sessionId,
+                    turnId: summary.turnId
+                });
+            }
+            else {
+                const activity = await getWixelSessionActivity({ ...base, sessionId });
+                pendingQuestion = activity.parkedQuestion;
+                turnInProgress = activity.turnInProgress;
+            }
+        }
+        catch (questionError) {
+            console.warn('[Wixel] pending question fetch failed:', questionError.message);
+        }
+    }
+    // Not yet picked up, or between steps: still the turn's own work.
+    if (!summary.done && !pendingQuestion)
+        turnInProgress = true;
+    // The widget's answer to a question opens its own turn when the question's
+    // turn had already ended; the agent only knows the earlier task.
+    const latest = liveCards.get(task.contextId)?.lastSentTask ?? null;
+    const newerTaskId = summary.done && latest && latest !== task.id ? latest : null;
+    const lines = [];
+    if (failed) {
+        lines.push(`The turn ended without a result (${summary.state})${summary.replyText ? `: ${summary.replyText}` : '.'}`);
+    }
+    else if (summary.done) {
+        lines.push(summary.replyText
+            ? `Wixel replied: ${summary.replyText}`
+            : 'The turn is done.');
+    }
+    else if (pendingQuestion) {
+        lines.push('The turn is parked on an interactive question awaiting the user.');
+    }
+    else {
+        lines.push('Wixel is actively working on this turn.');
+    }
+    if (delivered) {
+        if (editorUrl)
+            lines.push(`Edit in Wixel: ${editorUrl}`);
+        lines.push(`<agent_instruction>The asset is READY — this reply is the final deliverable. You MUST now call get_wixel_asset_result with EXACTLY these arguments: ${ids}, assetIds: ${JSON.stringify(summary.assetIds)}, mediaUrls: ${JSON.stringify(summary.mediaUrls)}, prompt: <the user's original request>. In widget-capable clients it renders the result card (preview + edit/download actions); otherwise present the reply as text${editorUrl ? ' and ALWAYS include the Edit in Wixel link' : ''}. Do NOT call get_wixel_pending_question now — if the reply offers optional follow-ups (restyle, edits), mention them as text.</agent_instruction>`);
+    }
+    else if (pendingQuestion) {
+        lines.push(`IMPORTANT: the agent is asking the user an interactive question (${pendingQuestion.questions
+            .map((question) => question.kind)
+            .join(', ')}; questionId: ${pendingQuestion.toolCallId}). If you have NOT yet displayed this questionId, you MUST now call get_wixel_pending_question (${ids}, questionId: "${pendingQuestion.toolCallId}") and follow its response instruction BEFORE responding to the user — do not present the question yourself. If you already displayed this questionId, the user simply hasn't answered it yet — do NOT end your turn (stopping breaks the flow): keep polling get_wixel_task (waitSeconds: 25) without re-calling get_wixel_pending_question.`);
+    }
+    else if (newerTaskId) {
+        lines.push(`<agent_instruction>A newer turn was sent in this conversation since (taskId: "${newerTaskId}") — the user's answer from the widget. Poll get_wixel_task (taskId: "${newerTaskId}", metaSiteId: "${metaSiteId}", waitSeconds: 25) instead.</agent_instruction>`);
+    }
+    else if (turnInProgress) {
+        // A working turn must not read as "waiting on the user" — the caller's
+        // next step is to keep polling, nothing else.
+        lines.push(`<agent_instruction>Wixel is actively generating — the user does NOT need to do anything. Do NOT end your turn and do NOT ask the user for input: call get_wixel_task again (taskId: "${taskId}", metaSiteId: "${metaSiteId}", waitSeconds: 25) and repeat until it reports the turn done, however many polls it takes.</agent_instruction>`);
+    }
+    return {
+        isError: false,
+        content: [{ type: 'text', text: lines.join('\n') }],
+        structuredContent: {
+            success: true,
+            state: summary.state,
+            done: summary.done,
+            replyText: summary.replyText,
+            assetIds: summary.assetIds,
+            mediaUrls: summary.mediaUrls,
+            contextId,
+            taskId,
+            hasPendingQuestion: !!pendingQuestion,
+            pendingQuestionId: pendingQuestion?.toolCallId ?? null,
+            turnInProgress,
+            editorUrl,
+            newerTaskId
+        }
+    };
+}
 export function addGetWixelStylePresetsTool(server, authStrategy, options = {}) {
     const { getSiteAuthHeaders } = authStrategy;
     registerAppTool(server, 'get_wixel_style_presets', {
@@ -995,13 +892,11 @@ export function addGetWixelStylePresetsTool(server, authStrategy, options = {})
 }
 // Widget-internal (not exposed to the model). The result card renders the
 // moment the request is sent and drives the rest of the flow itself: it polls
-// this for the answer's turn and gets back "generating", a "question" to show
-// inline, the "done" assets, or "failed". The inbox is replayed from cursor
-// "0" with an explicit cursor, so the cursor list_wixel_events remembers per
-// handle for the agent is never advanced. "Done" is the reply/failed event of
-// the turn — the same signal the agent would have waited on; the entries log
-// only decides whether the turn is parked on a question, because the agent
-// emits text mid-turn and that log cannot tell it from the final reply.
+// this for the answer's task and gets back "generating", a "question" to show
+// inline, the "done" assets, or "failed". "Done" is the task's terminal state
+// — the same signal the agent would have waited on with get_wixel_task; the
+// entries log only decides whether the turn is parked on a question, because
+// a parked turn's task stays WORKING.
 // `ui.visibility` is what MCP Apps hosts read; ChatGPT reads
 // `openai/visibility` instead, so both are set or its model would see the tool.
 const WIDGET_ONLY_TOOL_META = {
@@ -1015,17 +910,12 @@ export function addGetWixelTurnResultTool(server, authStrategy, options = {}) {
         title: 'Get Wixel turn result',
         description: 'Widget-internal: the live result card polls this for the outcome of a turn (generating, a question to answer, the delivered assets, or a failure). Not needed for normal conversation flows.',
         inputSchema: {
-            handle: z.string().describe('Session handle from start_wixel_session'),
-            metaSiteId: z
-                .string()
-                .describe('Meta site ID from start_wixel_session'),
-            turnId: z
-                .string()
-                .describe('The turn to report on (returned by send_wixel_message)'),
+            taskId: taskIdInput,
+            metaSiteId: metaSiteIdInput,
             live: z
                 .boolean()
                 .optional()
-                .describe('Set by the live result card: marks the turn as followed by the card, so the agent is told to stand back for it.')
+                .describe('Set by the live result card: marks the task as followed by the card, so the agent is told to stand back for it.')
         },
         annotations: {
             readOnlyHint: true,
@@ -1034,53 +924,46 @@ export function addGetWixelTurnResultTool(server, authStrategy, options = {}) {
         },
         _meta: WIDGET_ONLY_TOOL_META
     }, async (args, extra) => {
-        setBi(extra, {
-            siteId: args.metaSiteId,
-            conversationId: args.handle
-        });
-        // A turn the live card follows — including the turns its inline
-        // answers open, which get_wixel_asset_result never saw.
-        if (args.live) {
-            const record = liveCards.forHandle(args.handle);
-            if (!record.turns.has(args.turnId)) {
-                record.turns.set(args.turnId, Date.now());
-            }
-        }
+        setBi(extra, { siteId: args.metaSiteId });
         const authHeaders = await getSiteAuthHeaders(args.metaSiteId);
         const base = {
             authHeaders,
             conductorOverride: options.conductorOverride
         };
         try {
-            const inbox = await listWixelSessionEvents({
+            const task = await getSiteTask({
                 ...base,
-                handle: args.handle,
-                metaSiteId: args.metaSiteId,
-                since: '0'
+                taskId: args.taskId,
+                metaSiteId: args.metaSiteId
+            });
+            const summary = summarizeTask(task);
+            const { sessionId } = summary;
+            setBi(extra, {
+                siteId: args.metaSiteId,
+                ...(sessionId ? { conversationId: sessionId } : {})
             });
-            if (inbox.error) {
-                throw new Error(`Failed to replay events: ${inbox.error} (${inbox.code ?? 'no code'})`);
+            // A task the live card follows — including the tasks its inline
+            // answers open, which get_wixel_asset_result never saw.
+            if (args.live) {
+                const record = liveCards.forContext(task.contextId);
+                if (!record.tasks.has(task.id)) {
+                    record.tasks.set(task.id, Date.now());
+                }
             }
-            const terminal = (inbox.events ?? []).find((event) => event.turnId === args.turnId &&
-                (event.type === 'reply' || event.type === 'failed'));
             let status = 'generating';
             let assets = [];
             let editorUrl = null;
             let pendingQuestion = null;
-            const replyText = terminal?.text ?? null;
-            if (terminal?.type === 'failed') {
+            const replyText = summary.done ? summary.replyText : null;
+            if (summary.done && summary.state !== 'TASK_STATE_COMPLETED') {
                 status = 'failed';
             }
-            else if (terminal) {
+            else if (summary.done) {
                 // Capped like the resolver's input, so what gets recorded as
                 // shown below is exactly what was considered for rendering.
-                const assetIds = extractAssetIds(terminal.text ?? '').slice(0, MAX_RESULT_ITEMS);
-                const mediaUrls = extractMediaUrls(terminal.text ?? '').slice(0, MAX_RESULT_ITEMS);
-                // Media URLs alone count only when the reply is not a question:
-                // an animation plan links the source image and asks for approval.
-                const delivers = assetIds.length > 0 ||
-                    (mediaUrls.length > 0 && !isQuestionReply(terminal.text ?? ''));
-                if (delivers) {
+                const assetIds = summary.assetIds.slice(0, MAX_RESULT_ITEMS);
+                const mediaUrls = summary.mediaUrls.slice(0, MAX_RESULT_ITEMS);
+                if (assetIds.length || mediaUrls.length) {
                     status = 'done';
                     // Only the live card displays what it resolves. The standalone
                     // question widget polls for the status alone: resolving for it
@@ -1089,7 +972,7 @@ export function addGetWixelTurnResultTool(server, authStrategy, options = {}) {
                     if (args.live) {
                         ({ assets, editorUrl } = await resolveWixelAssetResults({
                             ...base,
-                            handle: args.handle,
+                            sessionId,
                             metaSiteId: args.metaSiteId,
                             assetIds,
                             mediaUrls
@@ -1098,7 +981,7 @@ export function addGetWixelTurnResultTool(server, authStrategy, options = {}) {
                         // resolution that came back empty (transient lookup failure)
                         // leaves the result for the agent's get_wixel_asset_result.
                         if (assets.length) {
-                            const record = liveCards.forHandle(args.handle);
+                            const record = liveCards.forContext(task.contextId);
                             [...assetIds, ...mediaUrls].forEach((item) => record.shownAssets.add(item));
                         }
                     }
@@ -1107,19 +990,22 @@ export function addGetWixelTurnResultTool(server, authStrategy, options = {}) {
                     // A reply without a delivery is either a question restated as
                     // text (its structured payload is still pending) or a plain
                     // message — the card shows it with a reply box.
-                    pendingQuestion = await getWixelPendingQuestion({
-                        ...base,
-                        sessionId: args.handle
-                    });
+                    pendingQuestion = sessionId
+                        ? await getWixelPendingQuestion({
+                            ...base,
+                            sessionId,
+                            turnId: summary.turnId
+                        })
+                        : null;
                     status = pendingQuestion ? 'question' : 'done';
                 }
             }
-            else {
-                // No terminal event yet: parked on a question (custom_widget asks
-                // park the turn without a reply event) or still generating.
+            else if (sessionId) {
+                // Still working: parked on a question (custom_widget asks park the
+                // turn without ending it) or generating.
                 const activity = await getWixelSessionActivity({
                     ...base,
-                    sessionId: args.handle
+                    sessionId
                 });
                 pendingQuestion = activity.parkedQuestion;
                 if (pendingQuestion)
@@ -1128,18 +1014,20 @@ export function addGetWixelTurnResultTool(server, authStrategy, options = {}) {
             console.log('[WixelResponseDump]', JSON.stringify({
                 tool: 'get_wixel_turn_result',
                 args,
+                state: summary.state,
                 status,
                 assets,
                 editorUrl,
                 pendingQuestionId: pendingQuestion?.toolCallId ?? null
             }).slice(0, 30000));
             if (args.live && (status === 'done' || status === 'failed')) {
-                liveCards.forHandle(args.handle).finishedTurns.add(args.turnId);
+                liveCards.forContext(task.contextId).finishedTasks.add(task.id);
             }
             const structuredContent = {
                 success: true,
                 status,
-                turnId: args.turnId,
+                taskId: task.id,
+                contextId: task.contextId,
                 assets,
                 editorUrl,
                 pendingQuestion,
@@ -1158,6 +1046,9 @@ export function addGetWixelTurnResultTool(server, authStrategy, options = {}) {
             };
         }
         catch (error) {
+            if (error instanceof WixelA2AError) {
+                return a2aErrorResult('Could not read the Wixel task', error);
+            }
             rethrowIfUnauthorized(error);
             console.error('❌ Error getting Wixel turn result:', error);
             const errorMessage = error.message;
@@ -1178,7 +1069,7 @@ async function resolveWixelAssetResults(args) {
     const { authHeaders } = args;
     const options = { conductorOverride: args.conductorOverride };
     // The model-facing schema caps these, but the live path feeds the resolver
-    // straight from a reply's text — cap here too, or one oversized reply
+    // straight from a task's artifacts — cap here too, or one oversized reply
     // fans out into an unbounded number of authenticated lookups.
     const cappedAssetIds = (args.assetIds ?? []).slice(0, MAX_RESULT_ITEMS);
     const cappedMediaUrls = (args.mediaUrls ?? []).slice(0, MAX_RESULT_ITEMS);
@@ -1187,11 +1078,13 @@ async function resolveWixelAssetResults(args) {
     // are perfectly renderable.
     let projectId = null;
     try {
-        projectId = await getWixelSessionProjectId({
-            authHeaders,
-            conductorOverride: options.conductorOverride,
-            sessionId: args.handle
-        });
+        projectId = args.sessionId
+            ? await getWixelSessionProjectId({
+                authHeaders,
+                conductorOverride: options.conductorOverride,
+                sessionId: args.sessionId
+            })
+            : null;
     }
     catch (projectError) {
         console.warn('[Wixel] editor link resolution failed:', projectError.message);
@@ -1365,34 +1258,32 @@ export function addGetWixelAssetResultTool(server, authStrategy, options = {}) {
     registerAppTool(server, 'get_wixel_asset_result', {
         title: 'Get Wixel asset result',
         description: `Render the result of a Wixel generation.
-In widget-capable clients call it RIGHT AFTER send_wixel_message with the returned turnId: it renders a live result card that shows generation progress, asks the user any questions Wixel has, and displays the final asset — no polling needed.
-Otherwise (or when a list_wixel_events reply already delivered assets) pass the assetIds and mediaUrls EXACTLY as returned by list_wixel_events (never invent ids — a turnId is NOT an asset id) and present the returned asset links as text, always including the Edit in Wixel link.`,
+In widget-capable clients call it RIGHT AFTER send_wixel_message with the returned contextId and taskId: it renders a live result card that shows generation progress, asks the user any questions Wixel has, and displays the final asset — no polling needed.
+Otherwise (or when get_wixel_task already reported the delivered assets) pass the assetIds and mediaUrls EXACTLY as get_wixel_task returned them (never invent ids — a taskId is NOT an asset id) and present the returned asset links as text, always including the Edit in Wixel link.`,
         inputSchema: {
-            handle: z.string().describe('Session handle from start_wixel_session'),
-            metaSiteId: z
-                .string()
-                .describe('Meta site ID from start_wixel_session'),
+            contextId: contextIdInput,
+            taskId: taskIdInput,
+            metaSiteId: metaSiteIdInput,
             // Bounded: one reply delivers a handful of assets, and each entry costs
             // an authenticated lookup or a redirect chase.
             assetIds: z
                 .array(z.string().min(1).max(200))
                 .max(MAX_RESULT_ITEMS)
                 .optional()
-                .describe('Asset ids delivered by the reply — copy from list_wixel_events assetIds'),
+                .describe('Asset ids the turn delivered — copy from get_wixel_task assetIds'),
             mediaUrls: z
                 .array(z.string().max(2048))
                 .max(MAX_RESULT_ITEMS)
                 .optional()
-                .describe('Media URLs embedded in the reply — copy from list_wixel_events mediaUrls'),
+                .describe('Media URLs the turn delivered — copy from get_wixel_task mediaUrls'),
+            // Required: besides heading the card, it is how the shared widget
+            // tells this tool's invocation from get_wixel_pending_question's —
+            // both carry the same conversation ids.
             prompt: z
                 .string()
-                .max(4000)
-                .optional()
-                .describe("The user's original generation request, shown above the preview"),
-            turnId: z
-                .string()
-                .optional()
-                .describe('The turn returned by send_wixel_message. Widget clients: pass this (without assetIds/mediaUrls) to render the live card while Wixel generates.')
+                .min(1)
+                .max(WIXEL_MESSAGE_MAX_LENGTH)
+                .describe("The user's original generation request, shown above the preview")
         },
         annotations: {
             readOnlyHint: true,
@@ -1401,26 +1292,29 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
         },
         _meta: QUESTION_TOOL_META
     }, async (args, extra) => {
-        setBi(extra, {
-            siteId: args.metaSiteId,
-            conversationId: args.handle
-        });
+        setBi(extra, { siteId: args.metaSiteId });
         const authHeaders = await getSiteAuthHeaders(args.metaSiteId);
+        const base = {
+            authHeaders,
+            conductorOverride: options.conductorOverride
+        };
         try {
+            // The card sends its answers into contextId, so it must be the
+            // task's own; the task also names the session behind the editor link.
+            const task = await getSiteTask({
+                ...base,
+                taskId: args.taskId,
+                metaSiteId: args.metaSiteId
+            });
+            if (task.contextId !== args.contextId)
+                return contextMismatchResult();
+            const { sessionId } = summarizeTask(task);
+            setBi(extra, {
+                siteId: args.metaSiteId,
+                ...(sessionId ? { conversationId: sessionId } : {})
+            });
             if (!args.assetIds?.length && !args.mediaUrls?.length) {
-                // Live mode: nothing to resolve yet — the widget follows the turn.
-                if (!args.turnId) {
-                    return {
-                        isError: true,
-                        content: [
-                            {
-                                type: 'text',
-                                text: 'Pass the turnId from send_wixel_message (widget clients) or the assetIds/mediaUrls a reply delivered.'
-                            }
-                        ],
-                        structuredContent: { success: false, error: 'missing turnId' }
-                    };
-                }
+                // Live mode: nothing to resolve yet — the widget follows the task.
                 if (options.supportsWidgets?.() !== true) {
                     return {
                         isError: false,
@@ -1428,19 +1322,19 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                             {
                                 type: 'text',
                                 text: `This client cannot render the live card.
-<agent_instruction>Poll list_wixel_events (handle: "${args.handle}", metaSiteId: "${args.metaSiteId}", waitSeconds: 25) until turnId "${args.turnId}" has a "reply" or "failed" event, then follow that response's instruction.</agent_instruction>`
+<agent_instruction>Poll get_wixel_task (taskId: "${args.taskId}", metaSiteId: "${args.metaSiteId}", waitSeconds: 25) until it reports the turn done, then follow that response's instruction.</agent_instruction>`
                             }
                         ],
                         structuredContent: {
                             success: false,
                             pending: true,
-                            turnId: args.turnId
+                            taskId: args.taskId
                         }
                     };
                 }
-                const record = liveCards.forHandle(args.handle);
-                if (record.turns.has(args.turnId)) {
-                    // Already rendered for this turn — a second card would show the
+                const record = liveCards.forContext(task.contextId);
+                if (record.tasks.has(task.id)) {
+                    // Already rendered for this task — a second card would show the
                     // same generation twice.
                     console.log('[WixelResponseDump]', JSON.stringify({
                         tool: 'get_wixel_asset_result',
@@ -1452,7 +1346,7 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                         success: true,
                         pending: true,
                         duplicate: true,
-                        turnId: args.turnId,
+                        taskId: args.taskId,
                         assets: [],
                         editorUrl: null,
                         prompt: args.prompt ?? null
@@ -1463,7 +1357,7 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                             {
                                 type: 'text',
                                 text: `The live result card for this turn is already displayed.
-<agent_instruction>Do not call any Wixel tool again for this generation. End your turn now WITHOUT writing any message — no summary, no "Wixel is working on it", nothing: the card already says it, and a sentence under it is redundant. If your client forces a reply, use at most two words.</agent_instruction>`
+<agent_instruction>Do not call any Wixel tool again for this generation. ${END_TURN_SILENTLY}</agent_instruction>`
                             },
                             {
                                 type: 'text',
@@ -1473,12 +1367,12 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                         structuredContent: duplicateContent
                     };
                 }
-                record.turns.set(args.turnId, Date.now());
+                record.tasks.set(task.id, Date.now());
                 console.log('[WixelResponseDump]', JSON.stringify({ tool: 'get_wixel_asset_result', args, live: true }));
                 const liveContent = {
                     success: true,
                     pending: true,
-                    turnId: args.turnId,
+                    taskId: args.taskId,
                     assets: [],
                     editorUrl: null,
                     prompt: args.prompt ?? null
@@ -1489,7 +1383,7 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                         {
                             type: 'text',
                             text: `The live result card is displayed to the user. It shows generation progress, lets the user answer any question Wixel asks, and displays the final asset with edit/download actions — all inside the card.
-<agent_instruction>Do NOT poll list_wixel_events and do NOT call get_wixel_pending_question — the card handles the rest of this generation itself. End your turn now WITHOUT writing any message — no summary, no "Wixel is working on it", nothing: the card already says it, and a sentence under it is redundant. If your client forces a reply, use at most two words.</agent_instruction>`
+<agent_instruction>Do NOT poll get_wixel_task and do NOT call get_wixel_pending_question — the card handles the rest of this generation itself. ${END_TURN_SILENTLY}</agent_instruction>`
                         },
                         { type: 'text', text: JSON.stringify(liveContent) }
                     ],
@@ -1497,10 +1391,10 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                     _meta: widgetResultMeta(server)
                 };
             }
-            // A live card already displays these assets (list_wixel_events or
-            // get_wixel_turn_result recorded them for a live turn) — rendering
+            // A live card already displays these assets (get_wixel_task or
+            // get_wixel_turn_result recorded them for a live task) — rendering
             // them again would put the result in the chat twice.
-            const shown = liveCards.get(args.handle)?.shownAssets;
+            const shown = liveCards.get(task.contextId)?.shownAssets;
             const requested = [...(args.assetIds ?? []), ...(args.mediaUrls ?? [])];
             if (options.supportsWidgets?.() === true &&
                 shown?.size &&
@@ -1523,7 +1417,7 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                         {
                             type: 'text',
                             text: `This result is already displayed by the live result card.
-<agent_instruction>Do NOT present the asset again (no links, no image). End your turn now WITHOUT writing any message — no summary, no "Wixel is working on it", nothing: the card already says it, and a sentence under it is redundant. If your client forces a reply, use at most two words.</agent_instruction>`
+<agent_instruction>Do NOT present the asset again (no links, no image). ${END_TURN_SILENTLY}</agent_instruction>`
                         },
                         { type: 'text', text: JSON.stringify(duplicateContent) }
                     ],
@@ -1531,9 +1425,8 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
                 };
             }
             const { assets, editorUrl } = await resolveWixelAssetResults({
-                authHeaders,
-                conductorOverride: options.conductorOverride,
-                handle: args.handle,
+                ...base,
+                sessionId,
                 metaSiteId: args.metaSiteId,
                 assetIds: args.assetIds,
                 mediaUrls: args.mediaUrls
@@ -1589,6 +1482,9 @@ Otherwise (or when a list_wixel_events reply already delivered assets) pass the
             };
         }
         catch (error) {
+            if (error instanceof WixelA2AError) {
+                return a2aErrorResult('Could not read the Wixel task', error);
+            }
             rethrowIfUnauthorized(error);
             console.error('❌ Error resolving Wixel asset result:', error);
             const errorMessage = error.message;
@@ -1605,9 +1501,8 @@ export function addWixelSessionTools(server, authStrategy, options = {}) {
         ...options,
         liveCards: options.liveCards ?? createLiveCardRegistry()
     };
-    addStartWixelSessionTool(server, authStrategy, shared);
     addSendWixelMessageTool(server, authStrategy, shared);
-    addListWixelEventsTool(server, authStrategy, shared);
+    addGetWixelTaskTool(server, authStrategy, shared);
     addGetWixelPendingQuestionTool(server, authStrategy, shared);
     addGetWixelAssetResultTool(server, authStrategy, shared);
     addGetWixelStylePresetsTool(server, authStrategy, shared);