@thorprovider/medusa-extended 1.11.2 → 1.11.5

package/src/dropshipper.test.ts

@@ -1421,3 +1421,95 @@ describe('DropshipperClient.deleteCustomerAddress', () => {
     expect(result.id).toBe('addr_1')
   })
 })
+
+// ---------------------------------------------------------------------------
+// AI Assistant — streaming (chatAssistantStream)
+// ---------------------------------------------------------------------------
+
+describe('DropshipperClient.chatAssistantStream', () => {
+  it('normalizes a text/event-stream UI-message stream into ChatStreamEvents', async () => {
+    const sse = [
+      'data: {"type":"start","messageId":"m1","messageMetadata":{"intent":"catalog_search"}}\n\n',
+      'data: {"type":"text-delta","delta":"Encontr","id":"m1"}\n\n',
+      'data: {"type":"text-delta","delta":"é 2 productos","id":"m1"}\n\n',
+      'data: {"type":"finish","messageId":"m1","messageMetadata":{"intent":"catalog_search","sources":[{"product_id":"p1","title":"Zapato","handle":"zapato","thumbnail":null,"sale_price":100,"cost_price":60,"margin_percent":40,"available_quantity":5,"variants_summary":[]}]}}\n\n',
+      'data: [DONE]\n\n',
+    ].join('')
+
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/ai/chat`, ({ request }) => {
+        requireBearerToken(request)
+        return new HttpResponse(sse, {
+          headers: { 'Content-Type': 'text/event-stream' },
+        })
+      }),
+    )
+
+    const stream = await client().chatAssistantStream({
+      messages: [{ role: 'user', content: 'productos con margen' }],
+    })
+
+    const reader = stream.getReader()
+    const events = []
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      events.push(value)
+    }
+
+    expect(events).toEqual([
+      { type: 'start', intent: 'catalog_search' },
+      { type: 'text-delta', delta: 'Encontr' },
+      { type: 'text-delta', delta: 'é 2 productos' },
+      {
+        type: 'finish',
+        intent: 'catalog_search',
+        sources: [
+          {
+            product_id: 'p1',
+            title: 'Zapato',
+            handle: 'zapato',
+            thumbnail: null,
+            sale_price: 100,
+            cost_price: 60,
+            margin_percent: 40,
+            available_quantity: 5,
+            variants_summary: [],
+          },
+        ],
+      },
+    ])
+  })
+
+  it('synthesizes a one-shot stream from a plain JSON greeting/other response', async () => {
+    server.use(
+      http.post(`${BASE}/admin/thor/dropshipper/ai/chat`, ({ request }) => {
+        requireBearerToken(request)
+        return HttpResponse.json({
+          answer: '¡Hola! ¿En qué puedo ayudarte?',
+          intent: 'greeting',
+          model_used: 'gpt-4o',
+          sources: [],
+        })
+      }),
+    )
+
+    const stream = await client().chatAssistantStream({
+      messages: [{ role: 'user', content: 'Hola' }],
+    })
+
+    const reader = stream.getReader()
+    const events = []
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      events.push(value)
+    }
+
+    expect(events).toEqual([
+      { type: 'start', intent: 'greeting' },
+      { type: 'text-delta', delta: '¡Hola! ¿En qué puedo ayudarte?' },
+      { type: 'finish', intent: 'greeting', sources: [] },
+    ])
+  })
+})

package/src/dropshipper.ts

@@ -158,6 +158,8 @@ import type {
   // AI Assistant Chat
   ChatRequest,
   ChatResponse,
+  ChatIntent,
+  ChatSource,
   // Profile
   GetMyProfileResponse,
   // Notifications
@@ -178,6 +180,41 @@ import { fetchBackendWithResilience } from './request-resilience';
 
 type FetchMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
 
+// ---------------------------------------------------------------------------
+// AI Assistant — streaming chat events
+// ---------------------------------------------------------------------------
+
+/**
+ * One event from the streamed AI assistant chat (`chatAssistantStream`).
+ *
+ * The backend returns a UI-message stream (SSE over `text/event-stream`) for
+ * catalog searches, and a plain JSON `ChatResponse` for greetings/other
+ * intents. `chatAssistantStream` normalizes both into this single event type so
+ * consumers can render incremental text and update the "thinking" label as the
+ * model progresses without knowing the transport details.
+ */
+export type ChatStreamEvent =
+  | {
+      type: 'start';
+      /** Semantic intent as soon as the backend resolves it. */
+      intent?: ChatIntent;
+    }
+  | {
+      type: 'text-delta';
+      /** A chunk of the assistant's answer, appended to the bubble. */
+      delta: string;
+    }
+  | {
+      type: 'finish';
+      intent: ChatIntent;
+      /** Products referenced by the answer (empty for greetings/other). */
+      sources: ChatSource[];
+    }
+  | {
+      type: 'error';
+      errorText: string;
+    };
+
 /**
  * Configuration required to instantiate the dropshipper client.
  */
@@ -330,6 +367,106 @@ export class DropshipperClient {
     );
   }
 
+  /**
+   * Stream the AI assistant's reply.
+   *
+   * Unlike `chatAssistant`, this surfaces the model's progress: the backend
+   * resolves the intent first and then streams the answer token by token
+   * (catalog searches) or returns the full answer in one shot (greetings/other).
+   * The response is normalized into a single `ReadableStream<ChatStreamEvent>`
+   * so callers can show a live "thinking" label and render text incrementally.
+   *
+   * `POST /admin/thor/dropshipper/ai/chat`
+   */
+  async chatAssistantStream(body: ChatRequest): Promise<ReadableStream<ChatStreamEvent>> {
+    const url = `${this.baseUrl}/admin/thor/dropshipper/ai/chat`;
+    this.logger.debug('[dropshipper] POST /admin/thor/dropshipper/ai/chat (stream)');
+
+    const init: RequestInit = {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+      },
+      body: JSON.stringify(body),
+    };
+
+    let response: Response;
+    try {
+      // This endpoint performs two LLM round-trips plus channel-scoped retrieval
+      // BEFORE it starts streaming (headers only flush when Stage 3 begins), so
+      // the default 10s timeout aborts legitimate catalog searches. Use a larger
+      // per-attempt timeout; once headers arrive the timer is cleared and the
+      // streamed body is unaffected. POST is a mutation, so on timeout/network it
+      // won't be retried — maxRetries:1 only guards against redundant 5xx/red work.
+      response = await fetchBackendWithResilience(url, init, {
+        timeoutMs: 60_000,
+        maxRetries: 1,
+      });
+    } catch (networkError: any) {
+      throw new ProviderAPIError(
+        `[dropshipper] Network error on POST /admin/thor/dropshipper/ai/chat: ${networkError.message}`,
+        'NETWORK_ERROR',
+        networkError,
+      );
+    }
+
+    if (!response.ok) {
+      let message = `HTTP ${response.status}`;
+      let errorCode: string | undefined;
+      let requestId: string | undefined;
+      let details: string | undefined;
+      try {
+        const json: any = await response.json();
+        message = json?.message ?? message;
+        errorCode = json?.error_code ?? json?.type;
+        requestId = json?.request_id;
+        details = json?.details;
+      } catch {
+        // ignore parse errors
+      }
+      this.logger.error(
+        `[dropshipper] POST /admin/thor/dropshipper/ai/chat failed status=${response.status} message=${message}` +
+          (errorCode ? ` error_code=${errorCode}` : '') +
+          (requestId ? ` request_id=${requestId}` : '') +
+          (details ? ` details=${details}` : '')
+      );
+      throw new ProviderAPIError(
+        `[dropshipper] POST /admin/thor/dropshipper/ai/chat failed: ${message}`,
+        `DROPSHIPPER_API_${response.status}`,
+        response.status,
+        {
+          message,
+          status: response.status,
+          errorCode,
+          requestId,
+          details,
+        },
+      );
+    }
+
+    const contentType = response.headers.get('content-type') ?? '';
+    if (contentType.includes('text/event-stream') && response.body) {
+      return mapUiMessageStreamToEvents(response.body, this.logger);
+    }
+
+    // Non-streamed reply (greeting/other): synthesize a one-shot event stream.
+    const data: ChatResponse = await response.json();
+    return new ReadableStream<ChatStreamEvent>({
+      start(controller) {
+        controller.enqueue({ type: 'start', intent: data.intent });
+        controller.enqueue({ type: 'text-delta', delta: data.answer });
+        controller.enqueue({
+          type: 'finish',
+          intent: data.intent,
+          sources: data.sources ?? [],
+        });
+        controller.close();
+      },
+    });
+  }
+
   // -------------------------------------------------------------------------
   // Notifications
   // -------------------------------------------------------------------------
@@ -1768,3 +1905,125 @@ export class DropshipperClient {
 
 // Re-export types used by callers so they don't need to import from @thorprovider/types directly.
 export type { DropshipperCategory, DropshipperPromotion, NotificationData, PriceUpdatedNotificationData, ProductAssignedNotificationData, StockChangeNotificationData, ManualAdminNotificationData, RawNotification, GetNotificationsOptions, GetNotificationsResponse, ChatRequest, ChatResponse, ChatMessage, ChatIntent, ChatSource, ChatSourceVariant } from '@thorprovider/types';
+
+// ---------------------------------------------------------------------------
+// AI Assistant — streaming helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Yields one parsed JSON object per `data:` line of a Server-Sent Events body.
+ */
+async function* parseSse(
+  stream: ReadableStream<Uint8Array>,
+  logger?: ReturnType<typeof createLogger>,
+): AsyncGenerator<unknown> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let frameIndex = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() ?? '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data:')) continue;
+        const payload = trimmed.slice(5).trim();
+        if (!payload || payload === '[DONE]') continue;
+        frameIndex += 1;
+        try {
+          yield JSON.parse(payload);
+        } catch (err: any) {
+          logger?.warn(
+            `[dropshipper] sse-malformed-frame frame=${frameIndex} payload=${payload.slice(0, 200)}`
+          );
+        }
+      }
+    }
+    const tail = buffer.trim();
+    if (tail.startsWith('data:')) {
+      const payload = tail.slice(5).trim();
+      if (payload && payload !== '[DONE]') {
+        frameIndex += 1;
+        try {
+          yield JSON.parse(payload);
+        } catch (err: any) {
+          logger?.warn(
+            `[dropshipper] sse-malformed-frame frame=${frameIndex} payload=${payload.slice(0, 200)}`
+          );
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/**
+ * Normalize the backend's UI-message stream (SSE of `UIMessageChunk` frames)
+ * into the consumer-friendly `ChatStreamEvent` type.
+ */
+function mapUiMessageStreamToEvents(
+  stream: ReadableStream<Uint8Array>,
+  logger?: ReturnType<typeof createLogger>,
+): ReadableStream<ChatStreamEvent> {
+  return new ReadableStream<ChatStreamEvent>({
+    async start(controller) {
+      let eventCount = 0;
+      for await (const raw of parseSse(stream, logger)) {
+        const chunk = raw as {
+          type?: string;
+          messageId?: string;
+          delta?: string;
+          errorText?: string;
+          messageMetadata?: { intent?: ChatIntent; sources?: ChatSource[] };
+        };
+        switch (chunk.type) {
+          case 'start':
+            controller.enqueue({
+              type: 'start',
+              intent: chunk.messageMetadata?.intent,
+            });
+            eventCount += 1;
+            break;
+          case 'text-delta':
+            if (chunk.delta !== undefined) {
+              controller.enqueue({ type: 'text-delta', delta: chunk.delta });
+              eventCount += 1;
+            }
+            break;
+          case 'finish':
+            controller.enqueue({
+              type: 'finish',
+              intent: chunk.messageMetadata?.intent ?? 'other',
+              sources: chunk.messageMetadata?.sources ?? [],
+            });
+            eventCount += 1;
+            break;
+          case 'error':
+            logger?.warn(
+              `[dropshipper] chat-stream-error errorText=${chunk.errorText}`
+            );
+            controller.enqueue({
+              type: 'error',
+              errorText: chunk.errorText ?? 'Error inesperado del asistente.',
+            });
+            eventCount += 1;
+            break;
+          default:
+            logger?.debug(
+              `[dropshipper] chat-stream-unknown-frame type=${chunk.type}`
+            );
+        }
+      }
+      logger?.debug(`[dropshipper] chat-stream-completed events=${eventCount}`);
+      controller.close();
+    },
+    cancel() {
+      stream.cancel?.();
+    },
+  });
+}

package/src/index.ts

@@ -7,5 +7,5 @@ export { MedusaAdminClient } from './admin';
 export type { MedusaAdminClientConfig } from './admin';
 
 export { DropshipperClient } from './dropshipper';
-export type { DropshipperClientConfig } from './dropshipper';
+export type { DropshipperClientConfig, ChatStreamEvent } from './dropshipper';