@kortexya/reasoninglayer 0.23.1 → 1.0.1

package/README.md

@@ -29,8 +29,9 @@ yarn add @kortexya/reasoninglayer
 import { ReasoningLayerClient, Value, TermInput, FeatureInput } from '@kortexya/reasoninglayer';
 
 const client = new ReasoningLayerClient({
-  baseUrl: 'http://localhost:8083',
+  baseUrl: 'https://platform.ovh.reasoninglayer.ai',
   tenantId: 'your-tenant-uuid',
+  auth: { mode: 'bearer', token: process.env.RL_API_TOKEN! },
 });
 
 // Create a sort hierarchy
@@ -113,19 +114,55 @@ console.log(result.solutions); // Solutions with bindings
 
 ```typescript
 const client = new ReasoningLayerClient({
-  baseUrl: 'http://localhost:8083',  // Required
-  tenantId: 'your-tenant-uuid',     // Required, sent as X-Tenant-Id
-  bearerToken: 'eyJhbGciOi...',     // Optional, sent as Authorization: Bearer
-  userId: 'user-uuid',              // Optional, sent as X-User-Id
-  namespaceId: 'ns-uuid',           // Optional, sent as X-Namespace-Id
-  maxRetries: 3,                    // Default: 3
-  timeoutMs: 30000,                 // Default: 30000ms
-  retryOn503: true,                 // Default: true
-  fetch: customFetch,               // Optional: custom fetch implementation
-  interceptors: [loggingMiddleware], // Optional: request/response middleware
+  baseUrl: 'https://platform.ovh.reasoninglayer.ai', // Required
+  tenantId: 'your-tenant-uuid',                      // Required, sent as X-Tenant-Id
+  auth: { mode: 'bearer', token: 'eyJ…' },           // Required — see Authentication below
+  userId: 'user-uuid',                       // Optional, sent as X-User-Id
+  namespaceId: 'ns-uuid',                    // Optional, sent as X-Namespace-Id
+  maxRetries: 3,                             // Default: 3
+  timeoutMs: 30000,                          // Default: 30000ms
+  retryOn503: true,                          // Default: false
+  fetch: customFetch,                        // Optional: custom fetch implementation
+  interceptors: [loggingMiddleware],         // Optional: request/response middleware
 });
 ```
 
+### Authentication
+
+The `auth` field is **required** and must be one of two modes. There is no
+unauthenticated mode — the SDK will not silently ship requests that the
+gateway would reject.
+
+**`bearer` — server-side / programmatic usage.** Send a long-lived API token
+(typically a service-account token issued by the auth gateway) on every
+request as `Authorization: Bearer <token>`.
+
+```typescript
+const client = new ReasoningLayerClient({
+  baseUrl: 'https://platform.ovh.reasoninglayer.ai',
+  tenantId: '550e8400-e29b-41d4-a716-446655440000',
+  auth: { mode: 'bearer', token: process.env.RL_API_TOKEN! },
+});
+```
+
+**`cookie` — in-browser SPA usage.** Rely on the session cookie set by the
+auth gateway after an interactive login. The SDK issues HTTP requests with
+`credentials: 'include'` so the cookie is attached even on cross-origin
+requests; WebSocket connections rely on the browser attaching the cookie
+automatically (same-origin).
+
+```typescript
+const client = new ReasoningLayerClient({
+  baseUrl: 'https://platform.ovh.reasoninglayer.ai',
+  tenantId: '550e8400-e29b-41d4-a716-446655440000',
+  auth: { mode: 'cookie' },
+});
+```
+
+The choice between modes belongs to the **deployment context** of the
+caller, not the SDK — pick `bearer` from servers and CI, `cookie` from
+browser code that has already gone through the platform's login flow.
+
 ## Response Metadata
 
 ```typescript

package/dist/index.cjs

@@ -7,7 +7,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "0.23.1";
+var SDK_VERSION = "1.0.1";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -15,13 +15,21 @@ function resolveConfig(config) {
   if (!config.tenantId) {
     throw new Error("ClientConfig.tenantId is required");
   }
+  if (!config.auth) {
+    throw new Error(
+      "ClientConfig.auth is required \u2014 pass { mode: 'bearer', token } or { mode: 'cookie' }"
+    );
+  }
+  if (config.auth.mode === "bearer" && !config.auth.token) {
+    throw new Error("ClientConfig.auth.token is required when mode is 'bearer'");
+  }
   return {
     baseUrl: config.baseUrl.replace(/\/+$/, ""),
     tenantId: config.tenantId,
     userId: config.userId,
     namespaceId: config.namespaceId,
     authenticatedUser: config.authenticatedUser,
-    bearerToken: config.bearerToken,
+    auth: config.auth,
     timeoutMs: config.timeoutMs ?? 3e4,
     maxRetries: config.maxRetries ?? 3,
     retryOn503: config.retryOn503 ?? false,
@@ -377,8 +385,8 @@ var WebSocketClient = class {
   buildUrl(path, params) {
     const baseUrl = this.config.baseUrl.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
     const queryParams = new URLSearchParams({ tenant_id: this.config.tenantId });
-    if (this.config.bearerToken) {
-      queryParams.set("token", this.config.bearerToken);
+    if (this.config.auth.mode === "bearer") {
+      queryParams.set("token", this.config.auth.token);
     }
     if (params) {
       for (const [key, value] of Object.entries(params)) {
@@ -617,7 +625,7 @@ function buildAuthHeaders(config) {
   if (config.userId) headers["X-User-Id"] = config.userId;
   if (config.namespaceId) headers["X-Namespace-Id"] = config.namespaceId;
   if (config.authenticatedUser) headers["X-Authenticated-User"] = config.authenticatedUser;
-  if (config.bearerToken) headers["Authorization"] = `Bearer ${config.bearerToken}`;
+  if (config.auth.mode === "bearer") headers["Authorization"] = `Bearer ${config.auth.token}`;
   return headers;
 }
 function transformRequestInit(init) {
@@ -644,10 +652,14 @@ function createCustomFetch(config) {
         const response = await executeFetch(input, transformedInit, timeoutMs, config);
         if (response.ok) return response;
         let body;
+        const rawText = await response.clone().text().catch(() => "");
         try {
-          body = await response.clone().json();
+          body = rawText ? JSON.parse(rawText) : { error: "unknown", message: `HTTP ${response.status}` };
         } catch {
-          body = { error: "unknown", message: `HTTP ${response.status}` };
+          body = {
+            error: "unknown",
+            message: rawText.trim() || `HTTP ${response.status}`
+          };
         }
         const apiError = createApiError(response.status, body, response.headers);
         if (response.status === 429 && attempt < maxRetries) {
@@ -685,7 +697,11 @@ async function executeFetch(input, init, timeoutMs, config) {
   const existingSignal = init?.signal;
   const combinedSignal = existingSignal ? AbortSignal.any([timeoutController.signal, existingSignal]) : timeoutController.signal;
   const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-  const request = new Request(url, { ...init, signal: combinedSignal });
+  const request = new Request(url, {
+    ...init,
+    signal: combinedSignal,
+    credentials: config.auth.mode === "cookie" ? "include" : "same-origin"
+  });
   try {
     const fetchFn = config.fetch;
     const baseFetch = (req) => fetchFn(req);
@@ -19393,10 +19409,14 @@ function ComponentHealthDtoFromApiToFront(dto) {
   };
 }
 function EnrichedHealthResponseFromApiToFront(dto) {
+  if (dto == null) {
+    return { buildInfo: void 0, components: [], status: "unknown" };
+  }
+  const rawBuildInfo = dto.build_info;
   return {
-    buildInfo: BuildInfoDtoFromApiToFront(dto.build_info),
-    components: dto.components.map(ComponentHealthDtoFromApiToFront),
-    status: dto.status
+    buildInfo: rawBuildInfo == null ? void 0 : BuildInfoDtoFromApiToFront(rawBuildInfo),
+    components: (dto.components ?? []).map(ComponentHealthDtoFromApiToFront),
+    status: dto.status ?? "unknown"
   };
 }