@thorprovider/medusa-extended 1.11.3 → 1.11.6

package/src/dropshipper.test.ts

@@ -1481,13 +1481,13 @@ describe('DropshipperClient.chatAssistantStream', () => {
     ])
   })
 
-  it('synthesizes a one-shot stream from a plain JSON greeting/other response', async () => {
+  it('synthesizes a one-shot stream from a plain JSON default 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',
+          intent: 'default',
           model_used: 'gpt-4o',
           sources: [],
         })
@@ -1507,9 +1507,9 @@ describe('DropshipperClient.chatAssistantStream', () => {
     }
 
     expect(events).toEqual([
-      { type: 'start', intent: 'greeting' },
+      { type: 'start', intent: 'default' },
       { type: 'text-delta', delta: '¡Hola! ¿En qué puedo ayudarte?' },
-      { type: 'finish', intent: 'greeting', sources: [] },
+      { type: 'finish', intent: 'default', sources: [] },
     ])
   })
 })

package/src/dropshipper.ts

@@ -160,6 +160,7 @@ import type {
   ChatResponse,
   ChatIntent,
   ChatSource,
+  ChatAssistantHealthResponse,
   // Profile
   GetMyProfileResponse,
   // Notifications
@@ -188,8 +189,8 @@ type FetchMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
  * 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
+ * catalog searches, and a plain JSON `ChatResponse` for `default` 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.
  */
@@ -207,7 +208,7 @@ export type ChatStreamEvent =
   | {
       type: 'finish';
       intent: ChatIntent;
-      /** Products referenced by the answer (empty for greetings/other). */
+      /** Products referenced by the answer (empty for `default` intents). */
       sources: ChatSource[];
     }
   | {
@@ -372,7 +373,7 @@ export class DropshipperClient {
    *
    * 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).
+   * (catalog searches) or returns the full answer in one shot (`default`).
    * The response is normalized into a single `ReadableStream<ChatStreamEvent>`
    * so callers can show a live "thinking" label and render text incrementally.
    *
@@ -394,7 +395,16 @@ export class DropshipperClient {
 
     let response: Response;
     try {
-      response = await fetchBackendWithResilience(url, init);
+      // 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}`,
@@ -405,25 +415,44 @@ export class DropshipperClient {
 
     if (!response.ok) {
       let message = `HTTP ${response.status}`;
+      let errorCode: string | undefined;
+      let requestId: string | undefined;
+      let details: string | undefined;
       try {
-        const json = await response.json();
+        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);
+      return mapUiMessageStreamToEvents(response.body, this.logger);
     }
 
-    // Non-streamed reply (greeting/other): synthesize a one-shot event stream.
+    // Non-streamed reply (`default`): synthesize a one-shot event stream.
     const data: ChatResponse = await response.json();
     return new ReadableStream<ChatStreamEvent>({
       start(controller) {
@@ -439,6 +468,69 @@ export class DropshipperClient {
     });
   }
 
+  /**
+   * Cheap liveness probe for the AI assistant.
+   *
+   * The backend performs no LLM or retrieval work, so this is safe to poll
+   * (e.g. from a dashboard availability indicator). Returns 200 with
+   * `available: true` when the assistant is configured; the backend answers
+   * HTTP 503 with `available: false` when `AI_GATEWAY_API_KEY` is missing.
+   *
+   * Deliberately does NOT go through `fetchBackendWithResilience`: that layer
+   * funnels every call through the SHARED `backendCircuitBreaker`, and the
+   * definitive 503 "not configured" answer would count as failures and could
+   * open the circuit, taking down all dropshipper API traffic. A health probe
+   * must stay isolated, with no retries and a short timeout.
+   *
+   * `GET /admin/thor/dropshipper/ai/health`
+   */
+  async chatAssistantHealth(): Promise<ChatAssistantHealthResponse> {
+    const url = `${this.baseUrl}/admin/thor/dropshipper/ai/health`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${this.token}` },
+        signal: controller.signal,
+        cache: 'no-store',
+      });
+    } catch (error: any) {
+      clearTimeout(timeoutId);
+      throw new ProviderAPIError(
+        `[dropshipper] Network error on GET /admin/thor/dropshipper/ai/health: ${error.message}`,
+        'NETWORK_ERROR',
+        0,
+      );
+    }
+    clearTimeout(timeoutId);
+
+    // 503 is the backend's definitive "not configured" answer, not a transient
+    // failure: parse it as a valid (unavailable) health response.
+    if (response.status === 503) {
+      try {
+        const body = await response.json();
+        if (body && typeof body.available === 'boolean') {
+          return body as ChatAssistantHealthResponse;
+        }
+      } catch {
+        // fall through to the generic failure below
+      }
+    }
+
+    if (!response.ok) {
+      throw new ProviderAPIError(
+        `[dropshipper] GET /admin/thor/dropshipper/ai/health failed: HTTP ${response.status}`,
+        `DROPSHIPPER_API_${response.status}`,
+        response.status,
+      );
+    }
+
+    return response.json() as Promise<ChatAssistantHealthResponse>;
+  }
+
   // -------------------------------------------------------------------------
   // Notifications
   // -------------------------------------------------------------------------
@@ -1887,10 +1979,12 @@ export type { DropshipperCategory, DropshipperPromotion, NotificationData, Price
  */
 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();
@@ -1903,10 +1997,13 @@ async function* parseSse(
         if (!trimmed.startsWith('data:')) continue;
         const payload = trimmed.slice(5).trim();
         if (!payload || payload === '[DONE]') continue;
+        frameIndex += 1;
         try {
           yield JSON.parse(payload);
-        } catch {
-          // Skip malformed frames.
+        } catch (err: any) {
+          logger?.warn(
+            `[dropshipper] sse-malformed-frame frame=${frameIndex} payload=${payload.slice(0, 200)}`
+          );
         }
       }
     }
@@ -1914,10 +2011,13 @@ async function* parseSse(
     if (tail.startsWith('data:')) {
       const payload = tail.slice(5).trim();
       if (payload && payload !== '[DONE]') {
+        frameIndex += 1;
         try {
           yield JSON.parse(payload);
-        } catch {
-          // Ignore trailing partial frame.
+        } catch (err: any) {
+          logger?.warn(
+            `[dropshipper] sse-malformed-frame frame=${frameIndex} payload=${payload.slice(0, 200)}`
+          );
         }
       }
     }
@@ -1932,10 +2032,12 @@ async function* parseSse(
  */
 function mapUiMessageStreamToEvents(
   stream: ReadableStream<Uint8Array>,
+  logger?: ReturnType<typeof createLogger>,
 ): ReadableStream<ChatStreamEvent> {
   return new ReadableStream<ChatStreamEvent>({
     async start(controller) {
-      for await (const raw of parseSse(stream)) {
+      let eventCount = 0;
+      for await (const raw of parseSse(stream, logger)) {
         const chunk = raw as {
           type?: string;
           messageId?: string;
@@ -1949,27 +2051,39 @@ function mapUiMessageStreamToEvents(
               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',
+              intent: chunk.messageMetadata?.intent ?? 'default',
               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() {