@wix/mcp 1.0.93 → 1.0.95

package/build/dts/wixel/{external-agent-api.js → wixel-session-entries.js}

@@ -1,15 +1,14 @@
 import { createHttpClient } from '@wix/http-client';
-import { startSession, sendMessage, listEvents } from '@wix/ambassador-www-wixel-agent-v1-external-agent/http';
-import { InboxHistoryMode, ProjectWorkspace } from '@wix/ambassador-www-wixel-agent-v1-external-agent/types';
-import { WIXEL_AGENT_EXTERNAL_API_BASE_URL } from './constants.js';
-export { InboxHistoryMode, ProjectWorkspace };
-// wixel-agent-service ExternalAgentService — the agent-to-agent session API
-// (StartSession / SendMessage / ListEvents). Replaces driving the Wixel
-// conversation through the genie chat service directly.
+import { WIXEL_AGENT_SESSIONS_API_BASE_URL } from './constants.js';
+// Reads of the Wixel agent's internal sessions API (wixel-agent-service):
+// the durable entries log of a session and the sessions listing. A2A tasks
+// report a turn's state and reply, but a parked ask_user question — the
+// structured outline / style / choice payload the widgets render — lives only
+// in the entries log. The session id comes from a task's metadata.
 const CONDUCTOR_OVERRIDE_HEADERS = {
     Cookie: 'petri_ovr=specs.wixel-slides.enableInWixel#true|specs.wixel-assistant.sidePanelEnabled#true|creditTransactionsPremiumIntegration#A'
 };
-function httpClientFor({ authHeaders, apiBaseURL = WIXEL_AGENT_EXTERNAL_API_BASE_URL, conductorOverride }) {
+function httpClientFor({ authHeaders, apiBaseURL = WIXEL_AGENT_SESSIONS_API_BASE_URL, conductorOverride }) {
     return createHttpClient({
         headers: {
             ...authHeaders,
@@ -18,31 +17,8 @@ function httpClientFor({ authHeaders, apiBaseURL = WIXEL_AGENT_EXTERNAL_API_BASE
         baseURL: apiBaseURL
     });
 }
-export async function startWixelSession({ sessionId, metaSiteId, callerName = 'Wix MCP', externalId, workspace, callbackUrl, callbackToken, ...base }) {
-    const httpClient = httpClientFor(base);
-    const { data } = await httpClient.request(startSession({
-        sessionId,
-        metaSiteId,
-        callerName,
-        externalId,
-        workspace,
-        callbackUrl,
-        callbackToken
-    }));
-    return data;
-}
-export async function sendWixelSessionMessage({ handle, metaSiteId, text, transactionId, ...base }) {
-    const httpClient = httpClientFor(base);
-    const { data } = await httpClient.request(sendMessage({ handle, metaSiteId, text, transactionId }));
-    return data;
-}
-export async function listWixelSessionEvents({ handle, metaSiteId, since, historyMode, ...base }) {
-    const httpClient = httpClientFor(base);
-    const { data } = await httpClient.request(listEvents({ handle, metaSiteId, since, historyMode }));
-    return data;
-}
-// DEBUG: internal wixel-agent sessions API — exposes the full durable session
-// entries (incl. parked ask_user questions the external inbox hides).
+// The full durable session entries, including parked ask_user questions,
+// which an A2A task does not carry.
 export async function getWixelSessionEntries({ sessionId, ...base }) {
     const httpClient = httpClientFor(base);
     const { data } = await httpClient.get(`/_api/wixel-agent-server/sessions/${sessionId}/messages`);
@@ -50,16 +26,15 @@ export async function getWixelSessionEntries({ sessionId, ...base }) {
 }
 // The sessions listing is scoped to the authenticated caller, so membership
 // in it is the ownership check for the internal per-session reads below —
-// a caller-supplied handle that isn't the caller's own session resolves to
-// nothing instead of another tenant's data. The external API returns
-// handle === sessionId today; if they ever diverge this fails closed.
+// a session id that isn't the caller's own session resolves to nothing
+// instead of another tenant's data.
 async function isSessionVisibleToCaller(sessionId, base) {
     const httpClient = httpClientFor(base);
     const { data } = await httpClient.get(`/_api/wixel-agent-server/sessions`);
     return !!data?.sessions?.some((entry) => entry.id === sessionId);
 }
-// The wixel-agent session is bound to the Wixel project it works in; the
-// external inbox API doesn't expose it, but the sessions listing does.
+// The wixel-agent session is bound to the Wixel project it works in; an A2A
+// task doesn't expose it, but the sessions listing does.
 export async function getWixelSessionProjectId({ sessionId, ...base }) {
     const httpClient = httpClientFor(base);
     const { data } = await httpClient.get(`/_api/wixel-agent-server/sessions`);
@@ -69,9 +44,9 @@ export async function getWixelSessionProjectId({ sessionId, ...base }) {
 /**
  * Classify the session's current state from the durable entries log with a
  * single read: parked on an ask_user question, actively generating, or idle.
- * Empty inbox polls use this to tell callers whether to keep waiting (turn
- * running) or to turn to the user (parked question) — an empty inbox alone
- * cannot distinguish the two.
+ * A task still WORKING uses this to tell callers whether to keep waiting
+ * (turn running) or to turn to the user (parked question) — the task state
+ * alone cannot distinguish the two.
  */
 export async function getWixelSessionActivity({ sessionId, ...base }) {
     if (!(await isSessionVisibleToCaller(sessionId, base))) {
@@ -128,8 +103,7 @@ export async function getWixelSessionActivity({ sessionId, ...base }) {
 // The generation job's terminal result carries "conversationEnded": true —
 // the deliverable was produced and the Wixel flow is complete. Any question
 // still attached to that turn (e.g. the courtesy "pick a new style?") must
-// not resurface as pending until the user speaks again. (The created-assets
-// marker only exists on inbox events, not in the entries log.)
+// not resurface as pending until the user speaks again.
 function flowEndedSinceLastUserMessage(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
@@ -148,11 +122,11 @@ function flowEndedSinceLastUserMessage(messages) {
     }
     return false;
 }
-// The external-session policy intercepts ask_user (client-facing tools are
-// disabled) and the agent falls back to plain text — but the structured
-// question is still durably persisted as a functionCall entry. Extract the
-// most recent one so MCP clients can render it as a widget.
-export async function getWixelPendingQuestion({ sessionId, requireParked = false, ...base }) {
+// On API sessions ask_user is intercepted (client-facing tools are disabled)
+// and the agent falls back to plain text — but the structured question is
+// still durably persisted as a functionCall entry. Extract the most recent one
+// so MCP clients can render it as a widget.
+export async function getWixelPendingQuestion({ sessionId, requireParked = false, turnId, ...base }) {
     if (!(await isSessionVisibleToCaller(sessionId, base)))
         return null;
     const data = (await getWixelSessionEntries({
@@ -162,14 +136,17 @@ export async function getWixelPendingQuestion({ sessionId, requireParked = false
     const messages = data?.messages ?? [];
     if (flowEndedSinceLastUserMessage(messages))
         return null;
+    const ownTurn = turnId && messages.some((message) => message.turnId === turnId)
+        ? turnId
+        : null;
     // Two states carry a question worth surfacing:
     // - Parked: ask_user is the newest entry — the policy hasn't answered it and
-    //   the turn is suspended waiting for the user (no reply event will come).
-    //   requireParked accepts only this state; empty inbox polls use it so a
-    //   question answered elsewhere (e.g. the Wixel UI) isn't resurfaced while
-    //   the turn keeps generating.
+    //   the turn is suspended waiting for the user (its task stays WORKING).
+    //   requireParked accepts only this state; polls of a running task use it
+    //   so a question answered elsewhere (e.g. the Wixel UI) isn't resurfaced
+    //   while the turn keeps generating.
     // - Fallback: the policy auto-responded to ask_user and the agent re-asked
-    //   in plain text (the reply event). The structured payload is still the
+    //   in plain text (the task's reply). The structured payload is still the
     //   better rendering, so the reply path returns it — until the user's own
     //   text answer supersedes it.
     let sawNewerEntry = false;
@@ -190,6 +167,8 @@ export async function getWixelPendingQuestion({ sessionId, requireParked = false
                     []);
                 if (!questions.length)
                     continue;
+                if (ownTurn && message.turnId !== ownTurn)
+                    return null;
                 return {
                     toolCallId: call.id,
                     turnId: message.turnId,
@@ -203,4 +182,4 @@ export async function getWixelPendingQuestion({ sessionId, requireParked = false
     }
     return null;
 }
-//# sourceMappingURL=external-agent-api.js.map
+//# sourceMappingURL=wixel-session-entries.js.map

package/build/dts/wixel/wixel-session-tools.d.ts

@@ -31,43 +31,38 @@ export type WixelDeck = {
     pageUrls: string[];
 };
 export declare function collectDecks(projectAssets: WixelAssetEntity[], deckIds: Set<string>): Map<string, WixelDeck>;
-export declare function extractAssetIds(text: string): string[];
 /**
- * Live result cards, per Wixel session handle: the turns a card was rendered
- * for (and when), the asset ids / media URLs those cards display, and the
- * last turn send_wixel_message opened. The model does not reliably obey "do
- * not poll" once a live card is up, so the tools enforce it: list_wixel_events
- * refuses while a card is active, get_wixel_asset_result refuses to render
- * the same result a second time, and get_wixel_pending_question stays quiet
- * for a question the card already shows.
+ * Live result cards, per Wixel conversation (contextId): the tasks a card was
+ * rendered for (and when), the asset ids / media URLs those cards display, and
+ * the last task send_wixel_message returned in the conversation — the card's
+ * own answers go through that tool too, so it is the task the card follows.
+ * The model does not reliably obey "do not poll" once a live card is up, so
+ * the tools enforce it: get_wixel_task refuses while a card follows the
+ * conversation's latest task, get_wixel_asset_result refuses to render the
+ * same result a second time, and get_wixel_pending_question stays quiet for a
+ * question the card already shows.
  *
- * One registry per server instance (like list_wixel_events' cursor memory),
- * so sessions never see each other's records. In-memory like that memory
- * too: a Durable Object wake-up starts empty, and the intercepts simply
- * don't apply until the next send.
+ * One registry per server instance, so MCP sessions never see each other's
+ * records. In-memory: a Durable Object wake-up starts empty, and the
+ * intercepts simply don't apply until the next send.
  */
 type LiveCardRecord = {
-    /** Turn id → when its live card was rendered. */
-    turns: Map<string, number>;
-    /** Turns whose card reached done/failed — the agent may poll again. */
-    finishedTurns: Set<string>;
+    /** Task id → when its live card was rendered. */
+    tasks: Map<string, number>;
+    /** Tasks whose card reached done/failed — the agent may poll again. */
+    finishedTasks: Set<string>;
     shownAssets: Set<string>;
-    lastSentTurn: string | null;
+    lastSentTask: string | null;
 };
 export type LiveCardRegistry = ReturnType<typeof createLiveCardRegistry>;
 export declare function createLiveCardRegistry(): {
-    get: (handle: string) => LiveCardRecord | undefined;
-    forHandle: (handle: string) => LiveCardRecord;
-    isActive: (handle: string, params: {
-        authHeaders: Record<string, string>;
-        conductorOverride?: string;
-        metaSiteId: string;
-    }) => Promise<boolean>;
+    get: (contextId: string) => LiveCardRecord | undefined;
+    forContext: (contextId: string) => LiveCardRecord;
+    isActive: (contextId: string, isTerminal: (taskId: string) => Promise<boolean>) => Promise<boolean>;
 };
 export declare function addGetWixelPendingQuestionTool(server: WixMcpServer, authStrategy: McpAuthenticationStrategy, options?: WixelSessionToolOptions): void;
-export declare function addStartWixelSessionTool(server: WixMcpServer, authStrategy: McpAuthenticationStrategy, options?: WixelSessionToolOptions): void;
 export declare function addSendWixelMessageTool(server: WixMcpServer, authStrategy: McpAuthenticationStrategy, options?: WixelSessionToolOptions): void;
-export declare function addListWixelEventsTool(server: WixMcpServer, authStrategy: McpAuthenticationStrategy, options?: WixelSessionToolOptions): void;
+export declare function addGetWixelTaskTool(server: WixMcpServer, authStrategy: McpAuthenticationStrategy, options?: WixelSessionToolOptions): void;
 export declare function addGetWixelStylePresetsTool(server: WixMcpServer, authStrategy: McpAuthenticationStrategy, options?: WixelSessionToolOptions): void;
 export type WixelTurnStatus = 'generating' | 'question' | 'done' | 'failed';
 export declare function addGetWixelTurnResultTool(server: WixMcpServer, authStrategy: McpAuthenticationStrategy, options?: WixelSessionToolOptions): void;