@wix/mcp 1.0.94 → 1.0.96

package/build/dts/wix-mcp-server.d.ts

@@ -19,6 +19,7 @@ interface ToolBiParams {
     assetId?: string;
     returnedRows?: number;
     originalLength?: number;
+    upload?: object;
 }
 type WixRequestHandlerExtra = RequestHandlerExtra<any, any> & {
     logger: Logger;
@@ -48,13 +49,21 @@ export declare class WixMcpServer extends McpServer {
     private gptAppSchemesEnabled;
     private openAiMcpAppsEnabled;
     private mcpAppsInMcpEnabled;
+    private registeredTools;
     constructor(serverInfo: Implementation, options?: ServerOptions, context?: WixMcpServerContext | undefined);
     setUserIdGetter(getUserId: () => string | undefined): void;
     getSessionId(): string;
-    /** The connected client's name: the host's getter (User-Agent fallback) first, then clientInfo. */
+    /** The connected client's name: the host's getter (initialize name, then User-Agent) first, then clientInfo. */
     clientName(): string | undefined;
     setClientNameGetter(getClientName: () => string | undefined): void;
     setUserAgentGetter(getUserAgent: () => string | undefined): void;
+    /** True when every named tool is registered and enabled in this session. */
+    hasTools(...names: string[]): boolean;
+    /**
+     * Sets the `instructions` the server returns at initialize. Call it before the transport
+     * connects. The SDK keeps them on the low-level server and has no setter for them.
+     */
+    setInstructions(instructions: string | undefined): void;
     setGptAppSchemesEnabled(enabled: boolean): void;
     isGptAppSchemesEnabled(): boolean;
     setOpenAiMcpAppsEnabled(enabled: boolean): void;

package/build/dts/wix-mcp-server.js

@@ -8,6 +8,7 @@ import { DEV_ENVIRONMENTS, getEnvironment } from './infra/environment.js';
 import { HttpClient } from '@wix/http-client';
 import { logger } from './infra/logger.js';
 import { createToolBiEvent, extractText, formatToolResultAdditionalFields } from './infra/tool-bi.js';
+import { serializeToolParamsForBi } from './infra/redact-personal-data.js';
 export class WixMcpServer extends McpServer {
     serverInfo;
     context;
@@ -22,6 +23,7 @@ export class WixMcpServer extends McpServer {
     gptAppSchemesEnabled = false;
     openAiMcpAppsEnabled = false;
     mcpAppsInMcpEnabled = true;
+    registeredTools = new Map();
     constructor(serverInfo, options, context) {
         super(serverInfo, options);
         this.serverInfo = serverInfo;
@@ -39,7 +41,7 @@ export class WixMcpServer extends McpServer {
     getSessionId() {
         return this.sessionId;
     }
-    /** The connected client's name: the host's getter (User-Agent fallback) first, then clientInfo. */
+    /** The connected client's name: the host's getter (initialize name, then User-Agent) first, then clientInfo. */
     clientName() {
         return this.getClientName?.() ?? this.server.getClientVersion()?.name;
     }
@@ -49,6 +51,18 @@ export class WixMcpServer extends McpServer {
     setUserAgentGetter(getUserAgent) {
         this.getUserAgent = getUserAgent;
     }
+    /** True when every named tool is registered and enabled in this session. */
+    hasTools(...names) {
+        return names.every((name) => this.registeredTools.get(name)?.enabled);
+    }
+    /**
+     * Sets the `instructions` the server returns at initialize. Call it before the transport
+     * connects. The SDK keeps them on the low-level server and has no setter for them.
+     */
+    setInstructions(instructions) {
+        this.server._instructions =
+            instructions;
+    }
     setGptAppSchemesEnabled(enabled) {
         this.gptAppSchemesEnabled = enabled;
     }
@@ -105,6 +119,7 @@ export class WixMcpServer extends McpServer {
             args[cbIndex] = this.wrapToolCallback(toolName, originalCb);
         }
         const registeredTool = super.tool.apply(this, args);
+        this.registeredTools.set(args[0], registeredTool);
         if (this.isGptAppSchemesEnabled() &&
             !registeredTool._meta?.securitySchemes) {
             registeredTool.update({
@@ -127,7 +142,9 @@ export class WixMcpServer extends McpServer {
             };
         }
         const wrappedCb = this.wrapToolCallback(name, cb);
-        return super.registerTool(name, config, wrappedCb);
+        const registeredTool = super.registerTool(name, config, wrappedCb);
+        this.registeredTools.set(name, registeredTool);
+        return registeredTool;
     }
     wrapToolCallback(toolName, originalCb) {
         const isDevEnvironment = DEV_ENVIRONMENTS.includes(this.nodeEnv);
@@ -170,7 +187,7 @@ export class WixMcpServer extends McpServer {
                 });
                 panorama.transaction(toolName).start({
                     toolInvocationId,
-                    params: JSON.stringify(argsBeforeExtra)
+                    params: serializeToolParamsForBi(argsBeforeExtra)
                 });
             }
             const startTime = performance.now();
@@ -186,7 +203,8 @@ export class WixMcpServer extends McpServer {
                 else {
                     additionalFields = formatToolResultAdditionalFields(cbResult, {
                         returnedRows: toolBiParams.returnedRows,
-                        originalLength: toolBiParams.originalLength
+                        originalLength: toolBiParams.originalLength,
+                        upload: toolBiParams.upload
                     }, {
                         name: this.getClientName?.() || this.server.getClientVersion()?.name,
                         userAgent: this.getUserAgent?.()
@@ -202,7 +220,7 @@ export class WixMcpServer extends McpServer {
                         context: {
                             toolName,
                             toolInvocationId,
-                            params: JSON.stringify(argsBeforeExtra),
+                            params: serializeToolParamsForBi(argsBeforeExtra),
                             error: JSON.stringify(cbResult, null, 2)
                         }
                     });
@@ -217,7 +235,7 @@ export class WixMcpServer extends McpServer {
                         context: {
                             toolName,
                             toolInvocationId,
-                            params: JSON.stringify(argsBeforeExtra),
+                            params: serializeToolParamsForBi(argsBeforeExtra),
                             error: errorBody
                         }
                     });
@@ -268,7 +286,7 @@ export class WixMcpServer extends McpServer {
                         errorBody,
                         toolInvocationId,
                         toolName,
-                        params: JSON.stringify(argsBeforeExtra),
+                        params: serializeToolParamsForBi(argsBeforeExtra),
                         origin: this.nodeEnv,
                         sessionId: this.sessionId,
                         executionResult: toolSucceeded ? 'Success' : 'Error',

package/build/dts/wixel/constants.d.ts

@@ -1,7 +1,14 @@
 export declare const WIXEL_ASSISTANT_V1_NO_ENTITY_API_BASE_URL = "https://manage.wix.com/";
 export declare const WWW_ASSET_V1_ASSET_API_BASE_URL = "https://manage.wix.com/";
 export { OPENAI_WIDGET_MIME_TYPE } from '../site-widget-tools/constants.js';
-export declare const WIXEL_AGENT_EXTERNAL_API_BASE_URL = "https://manage.wix.com/";
+/** Base for the Wixel agent's A2aService ambassador package. Host only: on a
+ *  Wix host the package's request paths already start with the service mount
+ *  (`/_api/wixel-agent-server/v1/a2a/...`), so a base that repeated the mount
+ *  would double it and every call would 404. manage.wix.com, not bo.wix.com:
+ *  the MCP server runs outside the Wix network. */
+export declare const WIXEL_AGENT_A2A_API_BASE_URL = "https://manage.wix.com/";
+/** Base of the Wixel agent's internal sessions API (entries log, listing). */
+export declare const WIXEL_AGENT_SESSIONS_API_BASE_URL = "https://manage.wix.com/";
 export declare const WIXEL_WIDGET_URI = "ui://widget/wixel-widget.html";
 /** PNG first: clients only have to support png/jpeg, and take the first icon
  *  they can render. */

package/build/dts/wixel/constants.js

@@ -1,7 +1,14 @@
 export const WIXEL_ASSISTANT_V1_NO_ENTITY_API_BASE_URL = 'https://manage.wix.com/';
 export const WWW_ASSET_V1_ASSET_API_BASE_URL = 'https://manage.wix.com/';
 export { OPENAI_WIDGET_MIME_TYPE } from '../site-widget-tools/constants.js';
-export const WIXEL_AGENT_EXTERNAL_API_BASE_URL = 'https://manage.wix.com/';
+/** Base for the Wixel agent's A2aService ambassador package. Host only: on a
+ *  Wix host the package's request paths already start with the service mount
+ *  (`/_api/wixel-agent-server/v1/a2a/...`), so a base that repeated the mount
+ *  would double it and every call would 404. manage.wix.com, not bo.wix.com:
+ *  the MCP server runs outside the Wix network. */
+export const WIXEL_AGENT_A2A_API_BASE_URL = 'https://manage.wix.com/';
+/** Base of the Wixel agent's internal sessions API (entries log, listing). */
+export const WIXEL_AGENT_SESSIONS_API_BASE_URL = 'https://manage.wix.com/';
 export const WIXEL_WIDGET_URI = 'ui://widget/wixel-widget.html';
 /** PNG first: clients only have to support png/jpeg, and take the first icon
  *  they can render. */

package/build/dts/wixel/index.d.ts

@@ -1,7 +1,7 @@
 import { McpAuthenticationStrategy } from '../auth/index.js';
 import { WixMcpServer } from '../wix-mcp-server.js';
 export { WIXEL_ICON_SVG_URL, WIXEL_ICON_PNG_URL } from './constants.js';
-export { addWixelSessionTools, addStartWixelSessionTool, addSendWixelMessageTool, addListWixelEventsTool } from './wixel-session-tools.js';
+export { addWixelSessionTools, addSendWixelMessageTool, addGetWixelTaskTool } from './wixel-session-tools.js';
 export { addGetWixelJobStatusTool } from './get-wixel-job-status-tool.js';
 export { addMarkWixelJobAsFulfilledTool } from './mark-wixel-job-as-fulfilled-tool.js';
 export { addGetWixelAssetTool } from './get-wixel-asset-tool.js';

package/build/dts/wixel/index.js

@@ -4,7 +4,7 @@ import { addGetWixelAssetTool } from './get-wixel-asset-tool.js';
 import { addGetWixelProjectAssetsTool } from './get-wixel-project-assets-tool.js';
 import { addWixelSessionTools } from './wixel-session-tools.js';
 export { WIXEL_ICON_SVG_URL, WIXEL_ICON_PNG_URL } from './constants.js';
-export { addWixelSessionTools, addStartWixelSessionTool, addSendWixelMessageTool, addListWixelEventsTool } from './wixel-session-tools.js';
+export { addWixelSessionTools, addSendWixelMessageTool, addGetWixelTaskTool } from './wixel-session-tools.js';
 export { addGetWixelJobStatusTool } from './get-wixel-job-status-tool.js';
 export { addMarkWixelJobAsFulfilledTool } from './mark-wixel-job-as-fulfilled-tool.js';
 export { addGetWixelAssetTool } from './get-wixel-asset-tool.js';
@@ -14,7 +14,7 @@ export function addWixelTools(server, authStrategy, options = {}) {
     addMarkWixelJobAsFulfilledTool(server, authStrategy, options);
     addGetWixelAssetTool(server, authStrategy, options);
     addGetWixelProjectAssetsTool(server, authStrategy, options);
-    // Agent-to-agent session API (wixel-agent-service ExternalAgentService)
+    // Conversation tools over the Wixel agent's A2A endpoint
     addWixelSessionTools(server, authStrategy, options);
 }
 //# sourceMappingURL=index.js.map

package/build/dts/wixel/wixel-a2a-client.d.ts

@@ -0,0 +1,83 @@
+import { TaskState, type Task } from '@wix/ambassador-www-wixel-agent-v1-agent-to-agent/types';
+/** The agent rejects longer message text. */
+export declare const WIXEL_MESSAGE_MAX_LENGTH = 32000;
+/** The media type of the artifact part that lists the generated asset ids. */
+export declare const WIXEL_ASSETS_MEDIA_TYPE = "application/vnd.wixel.assets+json";
+export { TaskState };
+/** A task as the service always returns it: with its id and contextId. */
+export type WixelTask = Task & {
+    id: string;
+    contextId: string;
+};
+/** A failed A2aService call: the HTTP status and the service's message. */
+export declare class WixelA2AError extends Error {
+    readonly status: number | null;
+    constructor(status: number | null, message: string);
+}
+interface BaseOptions {
+    authHeaders: Record<string, string>;
+    conductorOverride?: string;
+    /** Override for tests and local runs. Host only — see
+     *  WIXEL_AGENT_A2A_API_BASE_URL. */
+    apiBaseURL?: string;
+}
+export interface SendWixelMessageOptions extends BaseOptions {
+    text: string;
+    /** The conversation to add a turn to; omit to start a new one. */
+    contextId?: string;
+    /** Reuse this site's Wixel project when starting a conversation. */
+    metaSiteId?: string;
+    /** Stable identifier of the caller's conversation (diagnostics only). */
+    externalId?: string;
+    /** Doubles as the turn's transaction id, so a retry with the same id is
+     *  one turn. Defaults to a fresh uuid per call. */
+    messageId?: string;
+}
+/**
+ * A2A SendMessage. Without a contextId the agent provisions a project (or
+ * reuses `metaSiteId`'s) and starts a session; with one it adds a turn. When a
+ * turn is still running the message steers it instead, and the running task
+ * comes back WORKING with `metadata.steered`.
+ */
+export declare function sendWixelMessage({ text, contextId, metaSiteId, externalId, messageId, ...base }: SendWixelMessageOptions): Promise<WixelTask>;
+export interface GetWixelTaskOptions extends BaseOptions {
+    taskId: string;
+}
+/** A2A GetTask: the turn's current state, reply and artifacts. */
+export declare function getWixelTask({ taskId, ...base }: GetWixelTaskOptions): Promise<WixelTask>;
+export declare function isTerminalTaskState(state: string | undefined): boolean;
+export declare function extractMediaUrls(text: string): string[];
+/**
+ * A text 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 ids only come with real
+ * deliveries; media URLs alone need this check.
+ */
+export declare function isQuestionReply(text: string): boolean;
+export interface WixelTaskSummary {
+    state: TaskState;
+    /** The turn has ended (completed, failed, canceled or rejected). */
+    done: boolean;
+    /** The agent's reply (completed) or failure reason, as text. */
+    replyText: string | null;
+    /** Generated asset ids, from the artifacts' wixel-assets parts. */
+    assetIds: string[];
+    /** Wix media URLs named in the artifacts' text — not counting an artifact
+     *  that asks the user something (see isQuestionReply). */
+    mediaUrls: string[];
+    contextId: string;
+    taskId: string;
+    sessionId: string | null;
+    metaSiteId: string | null;
+    turnId: string | null;
+    /** The message was steered into a turn that was already running. */
+    steered: boolean;
+}
+/**
+ * What a task means to the tools. Asset ids are read from the artifacts'
+ * `wixel-assets` data parts (one artifact per mid-turn deliverable plus the
+ * final `response`); media URLs still come from the text. A turn delivered
+ * something when either list is non-empty.
+ */
+export declare function summarizeTask(task: WixelTask): WixelTaskSummary;
+//# sourceMappingURL=wixel-a2a-client.d.ts.map

package/build/dts/wixel/wixel-a2a-client.js

@@ -0,0 +1,166 @@
+import { createHttpClient, HttpError } from '@wix/http-client';
+import { getTask, sendMessage } from '@wix/ambassador-www-wixel-agent-v1-agent-to-agent/http';
+import { Role, TaskState } from '@wix/ambassador-www-wixel-agent-v1-agent-to-agent/types';
+import { WIXEL_AGENT_A2A_API_BASE_URL } from './constants.js';
+// Client for the Wixel agent's A2aService (wixel-agent-service), through its
+// ambassador package. SendMessage starts a session or adds a turn to one, and
+// returns the turn as a task; GetTask reads that task back. Both ids it hands
+// out — contextId (the conversation) and taskId (one turn) — are opaque:
+// never decode them. The session, site and turn come from task.metadata.
+const CONDUCTOR_OVERRIDE_HEADERS = {
+    Cookie: 'petri_ovr=specs.wixel-slides.enableInWixel#true|specs.wixel-assistant.sidePanelEnabled#true|creditTransactionsPremiumIntegration#A'
+};
+/** Shown to the agent as who is talking to it. */
+const CALLER_NAME = 'Wix MCP';
+/** The agent rejects longer message text. */
+export const WIXEL_MESSAGE_MAX_LENGTH = 32000;
+/** The media type of the artifact part that lists the generated asset ids. */
+export const WIXEL_ASSETS_MEDIA_TYPE = 'application/vnd.wixel.assets+json';
+export { TaskState };
+const TERMINAL_STATES = new Set([
+    TaskState.TASK_STATE_COMPLETED,
+    TaskState.TASK_STATE_FAILED,
+    TaskState.TASK_STATE_CANCELED,
+    TaskState.TASK_STATE_REJECTED
+]);
+/** A failed A2aService call: the HTTP status and the service's message. */
+export class WixelA2AError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'WixelA2AError';
+    }
+}
+function httpClientFor({ authHeaders, conductorOverride, apiBaseURL = WIXEL_AGENT_A2A_API_BASE_URL }) {
+    return createHttpClient({
+        headers: {
+            ...authHeaders,
+            ...(conductorOverride ? { ...CONDUCTOR_OVERRIDE_HEADERS } : {})
+        },
+        baseURL: apiBaseURL
+    });
+}
+function requireTask(task, what) {
+    if (!task?.id || !task.contextId) {
+        throw new WixelA2AError(null, `Wixel returned no task ${what}`);
+    }
+    return { ...task, id: task.id, contextId: task.contextId };
+}
+function toWixelA2AError(error) {
+    if (!(error instanceof HttpError))
+        return error;
+    const data = error.response?.data;
+    const message = typeof data?.message === 'string' && data.message
+        ? data.message
+        : error.message;
+    return new WixelA2AError(error.response?.status ?? null, message);
+}
+/**
+ * A2A SendMessage. Without a contextId the agent provisions a project (or
+ * reuses `metaSiteId`'s) and starts a session; with one it adds a turn. When a
+ * turn is still running the message steers it instead, and the running task
+ * comes back WORKING with `metadata.steered`.
+ */
+export async function sendWixelMessage({ text, contextId, metaSiteId, externalId, messageId = crypto.randomUUID(), ...base }) {
+    try {
+        const { data } = await httpClientFor(base).request(sendMessage({
+            message: {
+                messageId,
+                role: Role.ROLE_USER,
+                parts: [{ text }],
+                ...(contextId ? { contextId } : {})
+            },
+            metadata: {
+                callerName: CALLER_NAME,
+                ...(externalId ? { externalId } : {}),
+                // A conversation is already bound to its site; the hint only
+                // matters when one is being started.
+                ...(metaSiteId && !contextId ? { metaSiteId } : {})
+            }
+        }));
+        return requireTask(data.task, 'for the message');
+    }
+    catch (error) {
+        throw toWixelA2AError(error);
+    }
+}
+/** A2A GetTask: the turn's current state, reply and artifacts. */
+export async function getWixelTask({ taskId, ...base }) {
+    try {
+        const { data } = await httpClientFor(base).request(getTask({ id: taskId }));
+        return requireTask(data.task, `for ${taskId}`);
+    }
+    catch (error) {
+        throw toWixelA2AError(error);
+    }
+}
+export function isTerminalTaskState(state) {
+    return !!state && TERMINAL_STATES.has(state);
+}
+// Image/video replies often carry no asset id — 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 the result resolver's
+// allowlist, or a URL it would accept never gets extracted in the first place.
+export 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)) : [];
+}
+/**
+ * A text 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 ids only come with real
+ * deliveries; media URLs alone need this check.
+ */
+export function isQuestionReply(text) {
+    return /\?\s*$/.test(text.trim());
+}
+function partsText(parts) {
+    return (parts ?? [])
+        .map((part) => (typeof part.text === 'string' ? part.text : ''))
+        .filter(Boolean)
+        .join('\n');
+}
+function partsAssetIds(parts) {
+    return (parts ?? []).flatMap((part) => {
+        if (part.mediaType !== WIXEL_ASSETS_MEDIA_TYPE)
+            return [];
+        const ids = part.data?.assetIds;
+        return Array.isArray(ids)
+            ? ids.filter((id) => typeof id === 'string' && !!id)
+            : [];
+    });
+}
+/**
+ * What a task means to the tools. Asset ids are read from the artifacts'
+ * `wixel-assets` data parts (one artifact per mid-turn deliverable plus the
+ * final `response`); media URLs still come from the text. A turn delivered
+ * something when either list is non-empty.
+ */
+export function summarizeTask(task) {
+    const artifacts = task.artifacts ?? [];
+    const artifactText = artifacts
+        .map((artifact) => partsText(artifact.parts))
+        .filter(Boolean);
+    const statusText = partsText(task.status?.message?.parts);
+    const replyText = statusText || artifactText.at(-1) || null;
+    const metadata = task.metadata ?? {};
+    const state = task.status?.state ?? TaskState.TASK_STATE_UNSPECIFIED;
+    return {
+        state,
+        done: isTerminalTaskState(state),
+        replyText,
+        assetIds: Array.from(new Set(artifacts.flatMap((artifact) => partsAssetIds(artifact.parts)))),
+        mediaUrls: Array.from(new Set(artifactText
+            .filter((text) => !isQuestionReply(text))
+            .flatMap(extractMediaUrls))),
+        contextId: task.contextId,
+        taskId: task.id,
+        sessionId: typeof metadata.sessionId === 'string' ? metadata.sessionId : null,
+        metaSiteId: typeof metadata.metaSiteId === 'string' ? metadata.metaSiteId : null,
+        turnId: typeof metadata.turnId === 'string' ? metadata.turnId : null,
+        steered: metadata.steered === true
+    };
+}
+//# sourceMappingURL=wixel-a2a-client.js.map

package/build/dts/wixel/wixel-bi.d.ts

@@ -12,7 +12,8 @@ export interface WixelToolBiParams {
  * registerAppTool types its extra as the bare SDK one; wrapToolCallback
  * injects both of these at runtime, hence the cast and the no-ops in tests.
  *
- * The handle goes on as a logger default because wrapToolCallback doesn't pass
+ * The Wixel session id (from the A2A task's metadata — never the opaque
+ * contextId) goes on as a logger default because wrapToolCallback doesn't pass
  * ai_conversation_id — the wrapper merges defaults into the event it reports
  * for this same invocation. The field is typed as a GUID.
  */

package/build/dts/wixel/wixel-bi.js

@@ -5,7 +5,8 @@ import { isValidUuid } from './utils.js';
  * registerAppTool types its extra as the bare SDK one; wrapToolCallback
  * injects both of these at runtime, hence the cast and the no-ops in tests.
  *
- * The handle goes on as a logger default because wrapToolCallback doesn't pass
+ * The Wixel session id (from the A2A task's metadata — never the opaque
+ * contextId) goes on as a logger default because wrapToolCallback doesn't pass
  * ai_conversation_id — the wrapper merges defaults into the event it reports
  * for this same invocation. The field is typed as a GUID.
  */

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

@@ -1,35 +1,8 @@
-import { InboxHistoryMode, ProjectWorkspace, type ListEventsResponse, type SendMessageResponse, type StartSessionResponse } from '@wix/ambassador-www-wixel-agent-v1-external-agent/types';
-export { InboxHistoryMode, ProjectWorkspace };
-export type { ListEventsResponse, SendMessageResponse, StartSessionResponse };
 interface BaseOptions {
     authHeaders: Record<string, string>;
     apiBaseURL?: string;
     conductorOverride?: string;
 }
-export interface StartWixelSessionOptions extends BaseOptions {
-    sessionId?: string;
-    metaSiteId?: string;
-    callerName?: string;
-    externalId?: string;
-    workspace?: ProjectWorkspace;
-    callbackUrl?: string;
-    callbackToken?: string;
-}
-export declare function startWixelSession({ sessionId, metaSiteId, callerName, externalId, workspace, callbackUrl, callbackToken, ...base }: StartWixelSessionOptions): Promise<StartSessionResponse>;
-export interface SendWixelSessionMessageOptions extends BaseOptions {
-    handle: string;
-    metaSiteId: string;
-    text: string;
-    transactionId?: string;
-}
-export declare function sendWixelSessionMessage({ handle, metaSiteId, text, transactionId, ...base }: SendWixelSessionMessageOptions): Promise<SendMessageResponse>;
-export interface ListWixelSessionEventsOptions extends BaseOptions {
-    handle: string;
-    metaSiteId: string;
-    since?: string;
-    historyMode?: InboxHistoryMode;
-}
-export declare function listWixelSessionEvents({ handle, metaSiteId, since, historyMode, ...base }: ListWixelSessionEventsOptions): Promise<ListEventsResponse>;
 export interface GetSessionEntriesOptions extends BaseOptions {
     sessionId: string;
 }
@@ -82,18 +55,23 @@ export interface WixelSessionActivity {
     /** Unanswered ask_user the turn is suspended on (nothing will generate
      *  until the user answers). */
     parkedQuestion: WixelPendingQuestion | null;
-    /** A turn is actively generating — a reply/failed event will arrive. */
+    /** A turn is actively generating — its task will reach a terminal state. */
     turnInProgress: boolean;
 }
 /**
  * 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 declare function getWixelSessionActivity({ sessionId, ...base }: GetSessionEntriesOptions): Promise<WixelSessionActivity>;
-export declare function getWixelPendingQuestion({ sessionId, requireParked, ...base }: GetSessionEntriesOptions & {
+export declare function getWixelPendingQuestion({ sessionId, requireParked, turnId, ...base }: GetSessionEntriesOptions & {
     requireParked?: boolean;
+    /** The asking task's turn. A question another turn of the session asked —
+     *  a newer task's — is not this task's to show. Applied only when the turn
+     *  is in the log: a task spanning background turns carries a minted key. */
+    turnId?: string | null;
 }): Promise<WixelPendingQuestion | null>;
-//# sourceMappingURL=external-agent-api.d.ts.map
+export {};
+//# sourceMappingURL=wixel-session-entries.d.ts.map