@robosystems/core 0.11.2 → 0.11.3

package/hooks/use-streaming-query.js

@@ -17,6 +17,18 @@ const getSDKExtensions = async () => {
         return null;
     }
 };
+/**
+ * Invalidate the current query run and end its stream. The generator (and
+ * its request) ends once its pending read settles; the read loop also checks
+ * the run number, so nothing from the old run is written.
+ */
+function stopRun(runRef, iteratorRef) {
+    var _a, _b, _c;
+    runRef.current++;
+    const iterator = iteratorRef.current;
+    iteratorRef.current = null;
+    (_c = (_b = (_a = iterator === null || iterator === void 0 ? void 0 : iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator)) === null || _b === void 0 ? void 0 : _b.catch) === null || _c === void 0 ? void 0 : _c.call(_b, () => undefined);
+}
 /**
  * Hook for streaming query results using SDK extensions when available
  * Falls back to manual SSE implementation for older SDK versions
@@ -34,19 +46,14 @@ export function useStreamingQuery() {
         cached: false,
         duration: null,
     });
-    const eventSourceRef = useRef(null);
     const startTimeRef = useRef(null);
-    const queryClientRef = useRef(null);
+    // Each query run gets a number; cancelling or resetting moves it on, and a
+    // run whose number is no longer current stops and writes nothing.
+    const runRef = useRef(0);
+    const iteratorRef = useRef(null);
+    const stopCurrentRun = useCallback(() => stopRun(runRef, iteratorRef), []);
     const reset = useCallback(() => {
-        var _a;
-        if (eventSourceRef.current) {
-            eventSourceRef.current.close();
-            eventSourceRef.current = null;
-        }
-        if ((_a = queryClientRef.current) === null || _a === void 0 ? void 0 : _a.close) {
-            queryClientRef.current.close();
-            queryClientRef.current = null;
-        }
+        stopCurrentRun();
         setState({
             isStreaming: false,
             results: [],
@@ -59,31 +66,30 @@ export function useStreamingQuery() {
             cached: false,
             duration: null,
         });
-    }, []);
+    }, [stopCurrentRun]);
     const cancelQuery = useCallback(() => {
-        var _a;
-        if (eventSourceRef.current) {
-            eventSourceRef.current.close();
-            eventSourceRef.current = null;
-        }
-        if ((_a = queryClientRef.current) === null || _a === void 0 ? void 0 : _a.close) {
-            queryClientRef.current.close();
-            queryClientRef.current = null;
-        }
+        stopCurrentRun();
         setState((prev) => (Object.assign(Object.assign({}, prev), { isStreaming: false, status: 'cancelled', error: 'Query was cancelled' })));
-    }, []);
+    }, [stopCurrentRun]);
     const executeQuery = useCallback(async (graphId, query, parameters) => {
+        // The run starts now, so a cancel while the SDK loads retires it.
+        stopRun(runRef, iteratorRef);
+        const runId = runRef.current;
         // Get SDK extensions at runtime
         const sdkExtensions = await getSDKExtensions();
+        if (runRef.current !== runId)
+            return;
         // Require SDK extensions - fail fast if not available
         if (!(sdkExtensions === null || sdkExtensions === void 0 ? void 0 : sdkExtensions.streamQuery)) {
             throw new Error('SDK extensions not available. Please install @robosystems/client with extensions support.');
         }
-        return executeQueryWithExtensions(graphId, query, sdkExtensions, parameters);
+        return executeQueryWithExtensions(runId, graphId, query, sdkExtensions, parameters);
     }, []);
     // Helper function to execute query with SDK extensions
-    const executeQueryWithExtensions = async (graphId, query, sdkExtensions, parameters) => {
+    const executeQueryWithExtensions = async (runId, graphId, query, sdkExtensions, parameters) => {
         var _a, e_1, _b, _c;
+        var _d;
+        const isCurrent = () => runRef.current === runId;
         try {
             // Reset state for new query
             setState({
@@ -101,14 +107,17 @@ export function useStreamingQuery() {
             startTimeRef.current = Date.now();
             // Use the centralized streamQuery function with proper authentication
             const iterator = sdkExtensions.streamQuery(graphId, query, parameters, 100);
+            iteratorRef.current = iterator;
             setState((prev) => (Object.assign(Object.assign({}, prev), { status: 'streaming' })));
             let rowCount = 0;
             const allResults = [];
             try {
-                for (var _d = true, iterator_1 = __asyncValues(iterator), iterator_1_1; iterator_1_1 = await iterator_1.next(), _a = iterator_1_1.done, !_a; _d = true) {
+                for (var _e = true, iterator_1 = __asyncValues(iterator), iterator_1_1; iterator_1_1 = await iterator_1.next(), _a = iterator_1_1.done, !_a; _e = true) {
                     _c = iterator_1_1.value;
-                    _d = false;
+                    _e = false;
                     const batch = _c;
+                    if (!isCurrent())
+                        return;
                     // Handle both single rows and batches
                     const rows = Array.isArray(batch) ? batch : [batch];
                     for (const row of rows) {
@@ -124,14 +133,20 @@ export function useStreamingQuery() {
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_d && !_a && (_b = iterator_1.return)) await _b.call(iterator_1);
+                    if (!_e && !_a && (_b = iterator_1.return)) await _b.call(iterator_1);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            const duration = Date.now() - startTimeRef.current;
+            if (!isCurrent())
+                return;
+            if (iteratorRef.current === iterator)
+                iteratorRef.current = null;
+            const duration = Date.now() - ((_d = startTimeRef.current) !== null && _d !== void 0 ? _d : Date.now());
             setState((prev) => (Object.assign(Object.assign({}, prev), { isStreaming: false, status: 'completed', results: allResults, totalRows: rowCount, currentRow: rowCount, progress: 100, duration })));
         }
         catch (error) {
+            if (!isCurrent())
+                return;
             const errorMessage = error instanceof Error ? error.message : 'Query execution failed';
             setState((prev) => (Object.assign(Object.assign({}, prev), { isStreaming: false, status: 'error', error: errorMessage })));
         }

package/index.d.ts

@@ -1,10 +1,11 @@
 export * as AuthCore from './auth-core';
-export { clearToken, getAuthHeader, getToken, getValidToken, handleAuthResponse, hasValidToken, storeToken, } from './auth-core/token-storage';
+export { clearToken, getAuthHeader, getRefreshToken, getToken, getValidToken, handleAuthResponse, hasValidToken, storeToken, } from './auth-core/token-storage';
 export { clearUserCookies, clearUserLocalStorage, clearUserSessionStorage, listUserData, performLogoutCleanup, resetUIState, } from './auth-core/cleanup';
 export { AppSwitcher, AuthGuard, AuthProvider, LoginRedirector, SignInForm, SignUpForm, useAuth, } from './auth-components';
 export { useApiError, useMediaQuery, useToast, useUser, useUserLimits, type ToastMessage, } from './hooks';
 export { createGraphContext, createGraphProvider, createUseGraphContext, EntityProvider, GraphContext, GraphProvider, OrgProvider, ServiceOfferingsProvider, SidebarProvider, useEntity, useGraphContext, useOrg, useServiceOfferings, useSidebarContext, type EntityContextValue, type EntityProviderProps, type GraphContextValue, type GraphProviderProps, type GraphState, type OrgContextState, type OrgContextValue, type OrgProviderProps, type ServiceOfferings, } from './contexts';
 export { clientGraphCookie, clientSidebarCookie, createMcpConnectorUrl, entityCookie, graphCookie, sidebarCookie, type EntityCookie, type GraphCookie, type McpConnectorUrl, type SidebarCookie, } from './lib';
+export { ApiError, errorStatus, extractErrorDetail, isApiError, isSessionRejection, isTransientError, toApiError, unwrapSdk, type SdkResult, } from './lib/sdk-errors';
 export { generateEntityUri, isUUID, UUID_REGEX } from './utils';
 export { clearGraphSelection, getGraphSelection, persistGraphSelection, } from './actions/graph-actions';
 export { clearEntitySelection, getEntitySelection, persistEntitySelection, } from './actions/entity-actions';
@@ -24,7 +25,9 @@ export { clients, EventType, executeQuery, monitorOperation, OperationClient, Qu
 export { cancelTask, getActiveTasks, pollTaskStatus, taskMonitor, } from './task-monitoring/taskMonitor';
 export { getProgressFromStep, useEntityCreationTask, useTaskMonitoring, type UseTaskMonitoringResult, } from './task-monitoring/hooks';
 export type { TaskCreateResponse, TaskMonitorState, TaskPollingOptions, TaskStatus, TaskStatusResponse, } from './task-monitoring';
-export { useGraphCreation, useOperationMonitoring, useRepositorySubscription, type OperationMonitorState, type UseOperationMonitoringResult, } from './task-monitoring/operationHooks';
+export { OperationOutcomeError, useGraphCreation, useOperationMonitoring, useRepositorySubscription, type OperationMonitorState, type UseOperationMonitoringResult, } from './task-monitoring/operationHooks';
+export { MONITORING_STOPPED } from './task-monitoring/operationMonitor';
+export { POLLING_CANCELLED } from './task-monitoring/taskMonitor';
 import { client } from '@robosystems/client';
 export { client };
 export type { APIKey, AppName, AuthContextType, AuthFlowStatus, AuthProviders, AuthUser, PasskeyEnrollmentResult, } from './auth-core';

package/index.js

@@ -2,7 +2,7 @@
 // Export auth-core with namespace to avoid conflicts
 export * as AuthCore from './auth-core';
 // Export token storage utilities for JWT authentication
-export { clearToken, getAuthHeader, getToken, getValidToken, handleAuthResponse, hasValidToken, storeToken, } from './auth-core/token-storage';
+export { clearToken, getAuthHeader, getRefreshToken, getToken, getValidToken, handleAuthResponse, hasValidToken, storeToken, } from './auth-core/token-storage';
 // Export auth cleanup utilities
 export { clearUserCookies, clearUserLocalStorage, clearUserSessionStorage, listUserData, performLogoutCleanup, resetUIState, } from './auth-core/cleanup';
 // Export auth-components
@@ -21,6 +21,8 @@ OrgProvider,
 ServiceOfferingsProvider, SidebarProvider, useEntity, useGraphContext, useOrg, useServiceOfferings, useSidebarContext, } from './contexts';
 // Export lib utilities
 export { clientGraphCookie, clientSidebarCookie, createMcpConnectorUrl, entityCookie, graphCookie, sidebarCookie, } from './lib';
+// Export the SDK error seam (unwrap an SDK result or throw ApiError)
+export { ApiError, errorStatus, extractErrorDetail, isApiError, isSessionRejection, isTransientError, toApiError, unwrapSdk, } from './lib/sdk-errors';
 // Export utils
 export { generateEntityUri, isUUID, UUID_REGEX } from './utils';
 // Export server actions
@@ -49,7 +51,9 @@ export { clients, EventType, executeQuery, monitorOperation, OperationClient, Qu
 export { cancelTask, getActiveTasks, pollTaskStatus, taskMonitor, } from './task-monitoring/taskMonitor';
 export { getProgressFromStep, useEntityCreationTask, useTaskMonitoring, } from './task-monitoring/hooks';
 // Export operation monitoring hooks
-export { useGraphCreation, useOperationMonitoring, useRepositorySubscription, } from './task-monitoring/operationHooks';
+export { OperationOutcomeError, useGraphCreation, useOperationMonitoring, useRepositorySubscription, } from './task-monitoring/operationHooks';
+export { MONITORING_STOPPED } from './task-monitoring/operationMonitor';
+export { POLLING_CANCELLED } from './task-monitoring/taskMonitor';
 // Configure and export client directly for convenience (since it's commonly used)
 import { client } from '@robosystems/client';
 import { getAuthHeader } from './auth-core/token-storage';

package/lib/index.d.ts

@@ -2,3 +2,4 @@ export { clientSidebarCookie, sidebarCookie, type SidebarCookie, } from './sideb
 export { clientGraphCookie, graphCookie, type GraphCookie, } from './graph-cookie';
 export { entityCookie, type EntityCookie } from './entity-cookie';
 export { createMcpConnectorUrl, type McpConnectorUrl } from './mcp-connector';
+export { ApiError, errorStatus, extractErrorDetail, isApiError, isSessionRejection, isTransientError, toApiError, unwrapSdk, type SdkResult, } from './sdk-errors';

package/lib/index.js

@@ -2,3 +2,4 @@ export { clientSidebarCookie, sidebarCookie, } from './sidebar-cookie';
 export { clientGraphCookie, graphCookie, } from './graph-cookie';
 export { entityCookie } from './entity-cookie';
 export { createMcpConnectorUrl } from './mcp-connector';
+export { ApiError, errorStatus, extractErrorDetail, isApiError, isSessionRejection, isTransientError, toApiError, unwrapSdk, } from './sdk-errors';

package/lib/sdk-errors.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The error seam for `@robosystems/client` calls.
+ *
+ * The generated SDK is built with `throwOnError: false`: an HTTP error, or a
+ * request that never reached the server, *resolves* with
+ * `{ data: undefined, error, response }` instead of rejecting. Code written
+ * as if the SDK throws (a `try/catch` around the call, or `response.data`
+ * read without checking `response.error`) treats every failure as success.
+ *
+ * `unwrapSdk` restores the throwing contract for one call at a time:
+ *
+ *   const graphs = unwrapSdk(await SDK.getGraphs())
+ *
+ * It returns `data`, or throws an `ApiError` carrying the HTTP status. The
+ * shared client's global `throwOnError` stays false on purpose — some call
+ * sites read `response.error` directly, and flipping the default would change
+ * all of them at once.
+ */
+/** Minimal shape of an SDK result (`responseStyle: 'fields'`, the default). */
+export interface SdkResult<T> {
+    data?: T;
+    error?: unknown;
+    response?: {
+        status?: number;
+    } | Response;
+}
+export declare class ApiError extends Error {
+    /**
+     * HTTP status of the refusal, or 0 when no response was received (network
+     * failure, CORS rejection, DNS). Use `isNetworkError` rather than testing 0.
+     */
+    readonly status: number;
+    /** Human-readable detail from the response body (FastAPI `detail`). */
+    readonly detail: string;
+    /** Machine-readable code when the body carries one. */
+    readonly code?: string;
+    /** The raw error value the SDK resolved with. */
+    readonly body: unknown;
+    constructor(init: {
+        status: number;
+        detail: string;
+        code?: string;
+        body?: unknown;
+    });
+    get isNetworkError(): boolean;
+}
+export declare function isApiError(error: unknown): error is ApiError;
+/**
+ * Pull `{ detail, code }` out of whatever the SDK resolved as `error`: a
+ * FastAPI body (`{ detail }`, `{ detail: { detail, code } }`,
+ * `{ detail: [...] }`), a plain string, or a thrown `Error`.
+ */
+export declare function extractErrorDetail(error: unknown): {
+    detail?: string;
+    code?: string;
+};
+/** Build an `ApiError` from an SDK result's `error` and `response`. */
+export declare function toApiError(error: unknown, response?: {
+    status?: number;
+} | Response | null): ApiError;
+/**
+ * Return the SDK result's `data`, or throw an `ApiError` when the call
+ * failed. A result whose `error` is set is a failure regardless of `data`.
+ */
+export declare function unwrapSdk<T>(result: SdkResult<T>): T;
+/** Status of an unknown error, or undefined when it carries none. */
+export declare function errorStatus(error: unknown): number | undefined;
+/**
+ * Whether a failed call is worth retrying: no response (network), rate
+ * limited, or a server error. A 4xx refusal is an answer, not a blip. An
+ * error that is not an `ApiError` (a malformed body, a thrown TypeError) is
+ * treated as transient.
+ */
+export declare function isTransientError(error: unknown): boolean;
+/**
+ * Whether an error is the server refusing the session itself (401, or 403
+ * for a deactivated account) rather than an outage or a network drop.
+ */
+export declare function isSessionRejection(error: unknown): boolean;

package/lib/sdk-errors.js

@@ -0,0 +1,148 @@
+/**
+ * The error seam for `@robosystems/client` calls.
+ *
+ * The generated SDK is built with `throwOnError: false`: an HTTP error, or a
+ * request that never reached the server, *resolves* with
+ * `{ data: undefined, error, response }` instead of rejecting. Code written
+ * as if the SDK throws (a `try/catch` around the call, or `response.data`
+ * read without checking `response.error`) treats every failure as success.
+ *
+ * `unwrapSdk` restores the throwing contract for one call at a time:
+ *
+ *   const graphs = unwrapSdk(await SDK.getGraphs())
+ *
+ * It returns `data`, or throws an `ApiError` carrying the HTTP status. The
+ * shared client's global `throwOnError` stays false on purpose — some call
+ * sites read `response.error` directly, and flipping the default would change
+ * all of them at once.
+ */
+export class ApiError extends Error {
+    constructor(init) {
+        super(init.detail);
+        this.name = 'ApiError';
+        this.status = init.status;
+        this.detail = init.detail;
+        this.code = init.code;
+        this.body = init.body;
+    }
+    get isNetworkError() {
+        return this.status === 0;
+    }
+}
+export function isApiError(error) {
+    return error instanceof ApiError;
+}
+const asString = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
+/** Join a FastAPI 422 `detail[]` list into one line. */
+function formatValidationList(items) {
+    return items
+        .map((item) => {
+        if (typeof item === 'string')
+            return item;
+        if (item && typeof item === 'object') {
+            const entry = item;
+            const msg = asString(entry.msg);
+            if (msg) {
+                const loc = Array.isArray(entry.loc)
+                    ? entry.loc.filter((part) => part !== 'body').join('.')
+                    : '';
+                return loc ? `${loc}: ${msg}` : msg;
+            }
+        }
+        return JSON.stringify(item);
+    })
+        .join(', ');
+}
+/**
+ * Pull `{ detail, code }` out of whatever the SDK resolved as `error`: a
+ * FastAPI body (`{ detail }`, `{ detail: { detail, code } }`,
+ * `{ detail: [...] }`), a plain string, or a thrown `Error`.
+ */
+export function extractErrorDetail(error) {
+    var _a, _b, _c, _d;
+    if (error == null)
+        return {};
+    if (typeof error === 'string')
+        return { detail: asString(error) };
+    if (error instanceof Error)
+        return { detail: asString(error.message) };
+    if (typeof error !== 'object')
+        return { detail: String(error) };
+    const body = error;
+    let code = (_a = asString(body.code)) !== null && _a !== void 0 ? _a : asString(body.error_code);
+    let detail;
+    const raw = body.detail;
+    if (typeof raw === 'string') {
+        detail = asString(raw);
+    }
+    else if (Array.isArray(raw)) {
+        detail = asString(formatValidationList(raw));
+    }
+    else if (raw && typeof raw === 'object') {
+        const nested = raw;
+        code = (_c = (_b = asString(nested.code)) !== null && _b !== void 0 ? _b : asString(nested.error_code)) !== null && _c !== void 0 ? _c : code;
+        if (typeof nested.detail === 'string') {
+            detail = asString(nested.detail);
+        }
+        else if (Array.isArray(nested.detail)) {
+            detail = asString(formatValidationList(nested.detail));
+        }
+        else {
+            detail = asString(nested.message);
+        }
+    }
+    detail = (_d = detail !== null && detail !== void 0 ? detail : asString(body.message)) !== null && _d !== void 0 ? _d : asString(body.error);
+    return { detail, code };
+}
+/** Build an `ApiError` from an SDK result's `error` and `response`. */
+export function toApiError(error, response) {
+    if (error instanceof ApiError)
+        return error;
+    const status = response && typeof response.status === 'number' ? response.status : 0;
+    const { detail, code } = extractErrorDetail(error);
+    return new ApiError({
+        status,
+        detail: detail !== null && detail !== void 0 ? detail : (status === 0
+            ? 'Unable to reach the server'
+            : `Request failed with status ${status}`),
+        code,
+        body: error,
+    });
+}
+/**
+ * Return the SDK result's `data`, or throw an `ApiError` when the call
+ * failed. A result whose `error` is set is a failure regardless of `data`.
+ */
+export function unwrapSdk(result) {
+    if (result && result.error !== undefined && result.error !== null) {
+        throw toApiError(result.error, result.response);
+    }
+    return result.data;
+}
+/** Status of an unknown error, or undefined when it carries none. */
+export function errorStatus(error) {
+    var _a, _b;
+    if (error instanceof ApiError)
+        return error.status;
+    const err = error;
+    const status = (_a = err === null || err === void 0 ? void 0 : err.status) !== null && _a !== void 0 ? _a : (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.status;
+    return typeof status === 'number' ? status : undefined;
+}
+/**
+ * Whether a failed call is worth retrying: no response (network), rate
+ * limited, or a server error. A 4xx refusal is an answer, not a blip. An
+ * error that is not an `ApiError` (a malformed body, a thrown TypeError) is
+ * treated as transient.
+ */
+export function isTransientError(error) {
+    if (!(error instanceof ApiError))
+        return true;
+    return error.status === 0 || error.status === 429 || error.status >= 500;
+}
+/**
+ * Whether an error is the server refusing the session itself (401, or 403
+ * for a deactivated account) rather than an outage or a network drop.
+ */
+export function isSessionRejection(error) {
+    return (error instanceof ApiError && (error.status === 401 || error.status === 403));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robosystems/core",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "Shared RoboSystems frontend core library (auth, contexts, task monitoring, UI components) for the RoboSystems Next.js apps",
   "license": "MIT",
   "private": false,

package/task-monitoring/hooks.js

@@ -1,7 +1,8 @@
 'use client';
 import * as SDK from '@robosystems/client';
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { taskMonitor } from './taskMonitor';
+import { unwrapSdk } from '../lib/sdk-errors';
+import { POLLING_CANCELLED, taskMonitor } from './taskMonitor';
 export function useTaskMonitoring() {
     const [state, setState] = useState({
         isLoading: false,
@@ -25,17 +26,16 @@ export function useTaskMonitoring() {
     }, []);
     const cancelTask = useCallback(async () => {
         if (currentTaskId.current) {
-            try {
-                await taskMonitor.cancelTask(currentTaskId.current);
-                setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, error: 'Task was cancelled', result: null })));
-            }
-            catch (error) {
-                console.error('Failed to cancel task:', error);
-                setState((prev) => (Object.assign(Object.assign({}, prev), { error: 'Failed to cancel task', result: null })));
-            }
+            const cancelled = await taskMonitor.cancelTask(currentTaskId.current);
+            setState((prev) => cancelled
+                ? Object.assign(Object.assign({}, prev), { isLoading: false, error: 'Task was cancelled', result: null }) : // Refused (typically already finished): monitoring continues and
+             Object.assign(Object.assign({}, prev), { error: 'Failed to cancel task' }));
         }
     }, []);
     const startMonitoring = useCallback(async (taskId, options) => {
+        if (currentTaskId.current && currentTaskId.current !== taskId) {
+            taskMonitor.stopPolling(currentTaskId.current);
+        }
         currentTaskId.current = taskId;
         setState({
             isLoading: true,
@@ -63,19 +63,29 @@ export function useTaskMonitoring() {
             return result.details || result;
         }
         catch (error) {
+            if (error instanceof Error && error.message === POLLING_CANCELLED) {
+                // Stopped locally (cancelTask or unmount); cancelTask reports
+                // its own outcome.
+                setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false })));
+                throw error;
+            }
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
             setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, error: errorMessage, result: null })));
             throw error;
         }
         finally {
-            currentTaskId.current = null;
+            // A newer run may have started meanwhile; leave its id in place.
+            if (currentTaskId.current === taskId)
+                currentTaskId.current = null;
         }
     }, []);
-    // Cleanup on unmount
+    // Unmount stops watching; the operation itself keeps running. Cancelling
+    // it on the server is an explicit user action (`cancelTask`), never a side
+    // effect of navigating away.
     useEffect(() => {
         return () => {
             if (currentTaskId.current) {
-                taskMonitor.cancelTask(currentTaskId.current);
+                taskMonitor.stopPolling(currentTaskId.current);
             }
         };
     }, []);
@@ -94,7 +104,7 @@ export function useEntityCreationTask() {
             const response = await SDK.createGraph({
                 body: entityData,
             });
-            const responseData = response.data;
+            const responseData = unwrapSdk(response);
             if (!(responseData === null || responseData === void 0 ? void 0 : responseData.operationId)) {
                 throw new Error('No operation ID returned from company creation');
             }

package/task-monitoring/operationHooks.d.ts

@@ -1,4 +1,16 @@
-import type { OperationStatus } from './operationMonitor';
+import type { OperationResult, OperationStatus } from './operationMonitor';
+/**
+ * Thrown by `startMonitoring` (and so by `createGraph`) when an operation
+ * ends in any state but `completed`. `status` is the terminal state;
+ * `'cancelled'` with `stopped: true` means monitoring was stopped locally
+ * and the operation may still be running.
+ */
+export declare class OperationOutcomeError extends Error {
+    readonly status: OperationStatus;
+    readonly operationId: string;
+    readonly stopped: boolean;
+    constructor(result: OperationResult);
+}
 export interface OperationMonitorState {
     isLoading: boolean;
     isMonitoring: boolean;
@@ -33,6 +45,11 @@ export declare function useGraphCreation(): {
         tags?: string[];
         instance_tier?: string;
         schema_extensions?: string[];
+        /**
+         * Generic graphs only: the node/relationship schema to apply. When
+         * omitted, a generic graph is created with an empty schema.
+         */
+        custom_schema?: Record<string, unknown>;
         create_entity?: boolean;
         company_name?: string;
         company_identifier?: string;
@@ -56,8 +73,10 @@ export declare function useGraphCreation(): {
     createGenericGraph: (graphData: {
         graph_name: string;
         description?: string;
+        tags?: string[];
         instance_tier?: string;
         schema_extensions?: string[];
+        custom_schema?: Record<string, unknown>;
         org_id?: string;
     }) => Promise<any>;
     startMonitoring: (operationId: string, options?: {
@@ -102,7 +121,7 @@ export declare function useMultipleOperations(): {
     operations: OperationMonitorState[];
     addOperation: (operationId: string, options?: {
         timeout?: number;
-    }) => Promise<import("./operationMonitor").OperationResult>;
+    }) => Promise<OperationResult>;
     cancelOperation: (operationId: string) => Promise<void>;
     removeOperation: (operationId: string) => void;
     clearAll: () => void;