@manta-eu/react 0.1.0

package/dist/hooks/useActionPlanDetail.d.ts

@@ -0,0 +1,28 @@
+export declare function useActionPlanDetail(planGraphIri: string | null): {
+    isLoading: boolean;
+    error: string | null;
+    plan: {
+        iri: string;
+        hasCurrentFacts: boolean;
+        hasExecutionHistory: boolean;
+        description: string | null;
+        duration: string | null;
+        state: import("@manta-eu/client").GQLActionPlanState;
+        primaryIntegration: import("@manta-eu/client").GQLIntegration | null;
+        estimatedCost?: import("@manta-eu/client").GQLQuantitativeValue | null;
+        estimatedReturn?: import("@manta-eu/client").GQLQuantitativeValue | null;
+        estimatedROI?: import("@manta-eu/client").GQLQuantitativeValue | null;
+        potentialProfit?: import("@manta-eu/client").GQLQuantitativeValue | null;
+        createdBy: {
+            __typename: "ActionPlanCreatedByManta";
+            reason?: string | null;
+            confidenceScore?: number | null;
+        } | {
+            __typename: "ActionPlanCreatedByUser";
+            id: string;
+            reason?: string | null;
+        };
+    } | null;
+    graphDocument: import("#ldo-ui").RdfGraph | null;
+};
+//# sourceMappingURL=useActionPlanDetail.d.ts.map

package/dist/hooks/useActionPlanDetail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActionPlanDetail.d.ts","sourceRoot":"","sources":["../../src/hooks/useActionPlanDetail.ts"],"names":[],"mappings":"AAIA,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;;;;;;;;;;;qBAcqI,CAAC;uBAAkD,CAAC;oBAA+C,CAAC;uBAAkD,CAAC;;;;;;;;;;;;EAD1V"}

package/dist/hooks/useActionPlanDetail.js

@@ -0,0 +1,15 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { adaptActionPlanDetail } from "./action-plan-detail-adapter.js";
+import { useActionPlanDetail as useLdoActionPlanDetail } from "#ldo-ui";
+export function useActionPlanDetail(planGraphIri) {
+    const result = useLdoActionPlanDetail({
+        planGraphIri: planGraphIri ?? "",
+        enabled: isPresent(planGraphIri),
+    });
+    const adapted = adaptActionPlanDetail(result.data);
+    return {
+        ...adapted,
+        isLoading: result.isLoading,
+        error: result.error instanceof Error ? result.error.message : result.error ? String(result.error) : null,
+    };
+}

package/dist/hooks/useActionPlanExecution.d.ts

@@ -0,0 +1,18 @@
+export type ExecuteActionPlanResult = {
+    success: true;
+    workflowId: string;
+} | {
+    success: false;
+    error: string;
+};
+export type UseActionPlanExecutionResult = {
+    isTriggered: boolean;
+    triggeredAtMs: number | null;
+    dryRun: boolean | null;
+    workflowId: string | null;
+    triggerError: string | null;
+    execute: (dryRun?: boolean) => Promise<ExecuteActionPlanResult>;
+    reset: () => void;
+};
+export declare function useActionPlanExecution(planGraphIri: string, chatIri?: string): UseActionPlanExecutionResult;
+//# sourceMappingURL=useActionPlanExecution.d.ts.map

package/dist/hooks/useActionPlanExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActionPlanExecution.d.ts","sourceRoot":"","sources":["../../src/hooks/useActionPlanExecution.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,uBAAuB,GAAG;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhH,MAAM,MAAM,4BAA4B,GAAG;IACzC,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAChE,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,4BAA4B,CAsF3G"}

package/dist/hooks/useActionPlanExecution.js

@@ -0,0 +1,81 @@
+import { useExecuteAgentActionPlanMutation } from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback, useState } from "react";
+import { useMantaClient } from "../providers/MantaClientProvider.js";
+import { invalidateActionPlanQueries } from "../shared/query-keys.js";
+export function useActionPlanExecution(planGraphIri, chatIri) {
+    const [isTriggered, setIsTriggered] = useState(false);
+    const [triggeredAtMs, setTriggeredAtMs] = useState(null);
+    const [dryRun, setDryRun] = useState(null);
+    const [workflowId, setWorkflowId] = useState(null);
+    const [triggerError, setTriggerError] = useState(null);
+    const { mantaClient } = useMantaClient();
+    const queryClient = useQueryClient();
+    const invalidateActionPlans = useCallback(() => {
+        void invalidateActionPlanQueries(queryClient, planGraphIri);
+    }, [queryClient, planGraphIri]);
+    const { mutateAsync } = useExecuteAgentActionPlanMutation(mantaClient, {
+        onSuccess: invalidateActionPlans,
+    });
+    const execute = useCallback(async (nextDryRun = false) => {
+        setIsTriggered(true);
+        setDryRun(nextDryRun);
+        setTriggeredAtMs(Date.now());
+        setWorkflowId(null);
+        setTriggerError(null);
+        try {
+            const result = await mutateAsync({
+                input: {
+                    namedGraphIri: planGraphIri,
+                    shaclShapeIri: planGraphIri,
+                    dryRun: nextDryRun,
+                    ...(isPresent(chatIri) && { chatIri }),
+                },
+            });
+            if (!result.executeActionPlan.success || result.executeActionPlan.error) {
+                const message = result.executeActionPlan.error ?? "Failed to start execution";
+                setTriggerError(message);
+                setIsTriggered(false);
+                setTriggeredAtMs(null);
+                setDryRun(null);
+                return { success: false, error: message };
+            }
+            const id = result.executeActionPlan.workflowId;
+            if (!id) {
+                const message = "No workflowId returned";
+                setTriggerError(message);
+                setIsTriggered(false);
+                setTriggeredAtMs(null);
+                setDryRun(null);
+                return { success: false, error: message };
+            }
+            setWorkflowId(id);
+            return { success: true, workflowId: id };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to execute action plan";
+            setTriggerError(message);
+            setIsTriggered(false);
+            setTriggeredAtMs(null);
+            setDryRun(null);
+            return { success: false, error: message };
+        }
+    }, [planGraphIri, chatIri, mutateAsync]);
+    const reset = useCallback(() => {
+        setIsTriggered(false);
+        setTriggeredAtMs(null);
+        setWorkflowId(null);
+        setTriggerError(null);
+        setDryRun(null);
+    }, []);
+    return {
+        isTriggered,
+        triggeredAtMs,
+        dryRun,
+        workflowId,
+        triggerError,
+        execute,
+        reset,
+    };
+}

package/dist/hooks/useActionPlans.d.ts

@@ -0,0 +1,44 @@
+import { GQLIntegration, type GQLActionPlanState, type GQLActionPlansQueryVariables } from "@manta-eu/client";
+import type { GraphQLClient } from "graphql-request";
+import { type ActionPlanIntegrationFilter, type ActionPlansApprovalFilter, type ActionPlansAvailabilityFilter } from "#ldo-ui";
+export declare const useActionPlansQueryKeyRoot: readonly ["ldo-ui", "action-plans-list"];
+export type ActionPlansVariables = GQLActionPlansQueryVariables & {
+    states?: GQLActionPlanState[];
+    graphIris?: string[];
+    integrations?: ActionPlanIntegrationFilter[];
+    lastRunFrom?: string;
+    lastRunTo?: string;
+    approval?: ActionPlansApprovalFilter;
+    availability?: ActionPlansAvailabilityFilter;
+};
+export type ActionPlan = {
+    iri: string;
+    hasCurrentFacts: boolean;
+    state: GQLActionPlanState;
+    statements: number;
+    subjects: number;
+    updatedAt: string | null;
+    lastRunAt: string | null;
+    dryRun: boolean;
+    description: string | null;
+    duration: string | null;
+    primaryIntegration: GQLIntegration | null;
+    actionCount: number;
+    completedActionCount: number;
+    actionCountByType: Array<{
+        typeName: string;
+        count: number;
+    }>;
+};
+export type ActionPlans = ActionPlan[];
+export declare function useActionPlans(_client: GraphQLClient, variables?: ActionPlansVariables, options?: {
+    enabled?: boolean;
+    refetchInterval?: number | false;
+}): {
+    plans: ActionPlan[];
+    count: number;
+    isLoading: boolean;
+    isPlaceholderData: boolean;
+    error: string | null;
+};
+//# sourceMappingURL=useActionPlans.d.ts.map

package/dist/hooks/useActionPlans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActionPlans.d.ts","sourceRoot":"","sources":["../../src/hooks/useActionPlans.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,kBAAkB,EAAE,KAAK,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAC9G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD,OAAO,EAGL,KAAK,2BAA2B,EAGhC,KAAK,yBAAyB,EAC9B,KAAK,6BAA6B,EAGnC,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,0BAA0B,0CAA8B,CAAC;AAEtE,MAAM,MAAM,oBAAoB,GAAG,4BAA4B,GAAG;IAChE,MAAM,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,CAAC,EAAE,2BAA2B,EAAE,CAAC;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,YAAY,CAAC,EAAE,6BAA6B,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,OAAO,CAAC;IACzB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,kBAAkB,EAAE,cAAc,GAAG,IAAI,CAAC;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/D,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,UAAU,EAAE,CAAC;AAoEvC,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,EACtB,SAAS,CAAC,EAAE,oBAAoB,EAChC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;CAAE;;;;;;EAuBlE"}

package/dist/hooks/useActionPlans.js

@@ -0,0 +1,75 @@
+import { GQLIntegration } from "@manta-eu/client";
+import { useMemo } from "react";
+import { match } from "ts-pattern";
+import { actionPlansListQueryKeyRoot, useActionPlansList, } from "#ldo-ui";
+export const useActionPlansQueryKeyRoot = actionPlansListQueryKeyRoot;
+function toActionPlansListVariables(input) {
+    const { search, orderBy, limit, offset, states, graphIris, integrations, lastRunFrom, lastRunTo, approval, availability, } = input ?? {};
+    return {
+        search: search ?? undefined,
+        orderBy: orderBy
+            ? {
+                field: orderBy.field,
+                direction: orderBy.direction === "ASC" ? "ASC" : "DESC",
+            }
+            : undefined,
+        limit: limit ?? undefined,
+        offset: offset ?? undefined,
+        states: states?.map((state) => state),
+        graphIris: graphIris ?? undefined,
+        integrations,
+        lastRunFrom,
+        lastRunTo,
+        approval,
+        availability,
+    };
+}
+function mapIntegration(integration) {
+    return match(integration)
+        .with("META", () => GQLIntegration.Meta)
+        .with("GOOGLE", () => GQLIntegration.Google)
+        .with("LINKEDIN", () => GQLIntegration.Linkedin)
+        .with("SHOPIFY", () => GQLIntegration.Shopify)
+        .with("SNAPCHAT", () => GQLIntegration.Snapchat)
+        .with("WOOCOMMERCE", () => GQLIntegration.Woocommerce)
+        .with(null, () => null)
+        .exhaustive();
+}
+function toActionPlan(summary) {
+    return {
+        iri: summary.iri,
+        hasCurrentFacts: summary.hasCurrentFacts,
+        state: summary.state,
+        statements: summary.statements,
+        subjects: summary.subjects,
+        updatedAt: null,
+        lastRunAt: summary.lastRunAt,
+        dryRun: summary.dryRun,
+        description: summary.description,
+        duration: summary.duration,
+        primaryIntegration: mapIntegration(summary.primaryIntegration),
+        actionCount: summary.actionCount,
+        completedActionCount: summary.completedActionCount,
+        actionCountByType: summary.actionCountByType,
+    };
+}
+export function useActionPlans(_client, variables, options) {
+    const result = useActionPlansList({
+        ...toActionPlansListVariables(variables),
+        enabled: options?.enabled,
+        refetchInterval: options?.refetchInterval ??
+            ((query) => {
+                const plans = query.state.data?.plans ?? [];
+                return plans.some((plan) => plan.state === "RUNNING") ? 3000 : false;
+            }),
+        keepPreviousData: true,
+    });
+    const plans = useMemo(() => (result.data?.plans ?? []).map(toActionPlan), [result.data]);
+    return {
+        plans,
+        count: result.data?.totalCount ?? 0,
+        isLoading: result.isLoading,
+        isPlaceholderData: result.isPlaceholderData,
+        error: result.error instanceof Error ? result.error.message : result.error ? String(result.error) : null,
+    };
+}

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,30 @@
+import { type MantaModelId } from "@manta-eu/client/shared/model";
+import type { OrgRoleDefinition } from "@manta-eu/client/shared/org-roles";
+import type { Datastore, User } from "../lib/chat-types.js";
+export type LoginStatusCheck = {
+    isSessionValid: boolean;
+};
+export type UseAuthResult = {
+    user: User | undefined;
+    datastore: Datastore | undefined;
+    datastores: Datastore[] | undefined;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    isOperator: boolean;
+    canManageTeam: boolean;
+    orgRoles: OrgRoleDefinition[];
+    canManageIntegrations: boolean;
+    /** True when the server has confirmed the session is valid, even if context hasn't loaded yet. */
+    isSessionValid: boolean;
+    /** True when the session is valid but fetching user context failed with a server error (retryable). */
+    contextFailed: boolean;
+    datastoreAccessGranted: boolean;
+    logout: () => Promise<void>;
+    canSwitchDatastore: boolean;
+    allowedModels: MantaModelId[];
+    error: string | undefined;
+    /** Re-checks login status against the server, bypassing cached/stale state. */
+    refetchLoginStatus: () => Promise<LoginStatusCheck>;
+};
+export declare function useAuth(): UseAuthResult;
+//# sourceMappingURL=useAuth.d.ts.map

package/dist/hooks/useAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAEA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAQ3E,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAGzD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;IACvB,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;IACpC,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,kGAAkG;IAClG,cAAc,EAAE,OAAO,CAAC;IACxB,uGAAuG;IACvG,aAAa,EAAE,OAAO,CAAC;IACvB,sBAAsB,EAAE,OAAO,CAAC;IAChC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,+EAA+E;IAC/E,kBAAkB,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACrD,CAAC;AAkDF,wBAAgB,OAAO,IAAI,aAAa,CA0HvC"}

package/dist/hooks/useAuth.js

@@ -0,0 +1,156 @@
+import { datastoreHeader } from "@manta-eu/client/shared/datastore-path";
+import { createHttpError, isHttpError } from "@manta-eu/client/shared/error-utils";
+import { isValidModelId } from "@manta-eu/client/shared/model";
+import { isCapability } from "@manta-eu/client/shared/permissions";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useEffect } from "react";
+import { toast } from "sonner";
+import { z } from "zod";
+import { useMantaClient } from "../providers/index.js";
+const loginStatusSchema = z.object({
+    valid: z.boolean(),
+    canSwitchDatastore: z.boolean(),
+    allowedModels: z.array(z.string()).default([]),
+});
+const datastoreSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    depth: z.number().optional(),
+    selectable: z.boolean().optional(),
+    badge: z.string().optional(),
+});
+const orgRoleSchema = z.object({
+    id: z.string(),
+    groupName: z.string(),
+    label: z.string(),
+    capabilities: z.array(z.string()).transform((values) => values.filter(isCapability)),
+});
+const contextResponseSchema = z.object({
+    datastoreAccessGranted: z.boolean().default(true),
+    user: z.object({
+        id: z.string(),
+        email: z.string(),
+        name: z.string().nullable().optional(),
+        isOperator: z.boolean(),
+        adminOrgs: z.array(z.string()).optional().default([]),
+        memberOrgs: z.array(z.string()).optional().default([]),
+        canManageIntegrations: z.boolean().optional().default(false),
+        canManageTeam: z.boolean().optional().default(false),
+        datastore: datastoreSchema.optional(),
+    }),
+    datastores: z.array(datastoreSchema),
+    orgRoles: z.array(orgRoleSchema).optional().default([]),
+});
+// A user with no datastore waits on an operator; the grant rides in the token, so recovery is a re-fetch.
+const awaitingDatastorePollMs = 15_000;
+function isAwaitingDatastore(context) {
+    if (!isPresent(context))
+        return false;
+    return !context.user.isOperator && !isPresent(context.user.datastore);
+}
+export function useAuth() {
+    const { mantaBaseUrl, datastoreId } = useMantaClient();
+    const queryClient = useQueryClient();
+    const logout = useCallback(async () => {
+        queryClient.clear();
+        window.location.href = "/logout";
+    }, [queryClient]);
+    const { data: loginStatus, isLoading: isLoginStatusLoading, error: loginStatusError, refetch: refetchLoginStatusQuery, } = useQuery({
+        queryKey: ["login-status"],
+        queryFn: async ({ signal }) => {
+            const res = await fetch(new URL("/api/login", mantaBaseUrl), {
+                credentials: "include",
+                headers: { Accept: "application/json" },
+                signal,
+            });
+            if (!res.ok)
+                throw new Error(`Login status check failed: ${res.status}`);
+            return loginStatusSchema.parse(await res.json());
+        },
+        retry: false,
+        refetchOnWindowFocus: true,
+        // Keycloak's SSO session idle timeout (default 30 min) only resets when a request
+        // actually reaches processMiddleware. A long WS-only chat session with no other HTTP
+        // traffic would otherwise let the underlying session go idle and die silently.
+        refetchInterval: 5 * 60 * 1000,
+        refetchIntervalInBackground: true,
+    });
+    const contextEnabled = !isLoginStatusLoading && !!loginStatus?.valid;
+    const { data: contextData, isLoading: isContextLoading, error: contextError, } = useQuery({
+        queryKey: ["user-context", datastoreId],
+        queryFn: async ({ signal }) => {
+            const res = await fetch(new URL("/api/data/context", mantaBaseUrl), {
+                credentials: "include",
+                headers: { ...datastoreHeader(datastoreId), Accept: "application/json" },
+                signal,
+            });
+            if (!res.ok) {
+                const body = await res.json().catch(() => null);
+                const message = body?.error ?? "user not available";
+                throw createHttpError(message, res.status);
+            }
+            return contextResponseSchema.parse(await res.json());
+        },
+        enabled: contextEnabled,
+        retry: false,
+        staleTime: Infinity,
+        refetchOnWindowFocus: (query) => isAwaitingDatastore(query.state.data),
+        refetchInterval: (query) => (isAwaitingDatastore(query.state.data) ? awaitingDatastorePollMs : false),
+        refetchIntervalInBackground: false,
+    });
+    useEffect(() => {
+        if (isLoginStatusLoading)
+            return;
+        // Only redirect if the user was previously authenticated (contextData exists)
+        // to avoid showing "session expired" on the initial unauthenticated load
+        if (loginStatus?.valid === false && contextData) {
+            toast.error("Your session has expired. Please sign in again.");
+            void logout();
+        }
+    }, [isLoginStatusLoading, loginStatus?.valid, contextData, logout]);
+    useEffect(() => {
+        if (!contextEnabled || !contextError)
+            return;
+        if (contextError.name === "AbortError")
+            return;
+        // EDGE CASE: Remove invalid token to not get stuck in a loop
+        // This is used only for edge cases where we can't reach external servers for context (e.g. Hasura) or
+        // when user exists only in Keycloak, but not Hasura, so we can't get their data at all
+        if (isHttpError(contextError) && [401, 403].includes(contextError.status)) {
+            toast.error("Your session has expired. Please sign in again.");
+            void logout();
+        }
+        else {
+            toast.error(`Failed to load user data. (${contextError.message})`);
+        }
+    }, [contextEnabled, contextError, logout]);
+    const user = contextData?.user
+        ? { id: contextData.user.id, email: contextData.user.email, name: contextData.user.name ?? undefined }
+        : undefined;
+    const refetchLoginStatus = useCallback(async () => {
+        const { data } = await refetchLoginStatusQuery();
+        return { isSessionValid: !!data?.valid };
+    }, [refetchLoginStatusQuery]);
+    return {
+        user,
+        datastore: contextData?.user?.datastore,
+        datastores: contextData?.datastores,
+        datastoreAccessGranted: contextData?.datastoreAccessGranted ?? true,
+        isOperator: contextData?.user?.isOperator ?? false,
+        canManageTeam: contextData?.user?.canManageTeam ?? false,
+        orgRoles: contextData?.orgRoles ?? [],
+        canManageIntegrations: contextData?.user?.canManageIntegrations ?? false,
+        // Also loading when login is valid but context hasn't arrived yet: covers the
+        // one-render gap between loginStatus resolving and isContextLoading flipping true.
+        isLoading: isLoginStatusLoading || isContextLoading || (contextEnabled && !contextData && !contextError),
+        isAuthenticated: isPresent(user),
+        isSessionValid: !!loginStatus?.valid,
+        contextFailed: contextEnabled && !!contextError && !(isHttpError(contextError) && [401, 403].includes(contextError.status)),
+        logout,
+        refetchLoginStatus,
+        canSwitchDatastore: loginStatus?.canSwitchDatastore ?? false,
+        allowedModels: (loginStatus?.allowedModels ?? []).filter(isValidModelId),
+        error: loginStatusError ? "Service is unavailable. Please try again later." : undefined,
+    };
+}

package/dist/hooks/useChatPanelSync.d.ts

@@ -0,0 +1,9 @@
+type ChatPanelSync = {
+    splitEligible: boolean;
+    chatOpen: boolean;
+    chatReady: boolean;
+    closeChat: () => void;
+};
+export declare function useChatPanelSync(): ChatPanelSync;
+export {};
+//# sourceMappingURL=useChatPanelSync.d.ts.map

package/dist/hooks/useChatPanelSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatPanelSync.d.ts","sourceRoot":"","sources":["../../src/hooks/useChatPanelSync.ts"],"names":[],"mappings":"AAeA,KAAK,aAAa,GAAG;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAgBF,wBAAgB,gBAAgB,IAAI,aAAa,CAgDhD"}

package/dist/hooks/useChatPanelSync.js

@@ -0,0 +1,69 @@
+import { buildPlanIri } from "@manta-eu/client/shared/agent-mode";
+import { ChatContextKind, isDraftChatContext } from "@manta-eu/client/shared/agent-types";
+import { expandPrefix } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { equals } from "ramda";
+import { useEffect, useMemo, useRef } from "react";
+import { useLocation, useMatch, useParams } from "react-router";
+import { toast } from "sonner";
+import { useChatManagerConnection } from "../providers/ChatManagerProvider.js";
+import { useChatPanel } from "../providers/ChatPanelContext.js";
+import { useActionPlanRouteState } from "../routes/plans/index.js";
+import { decodeRuleRouteName } from "../routes/rules/components/rules.utils.js";
+import { computePlanSplitSidebarSync } from "./plan-split-sidebar-sync.js";
+import { useSidebar } from "#components/sidebar/index";
+function routeChatContext(planName, ruleName) {
+    if (isPresent(planName)) {
+        return { kind: ChatContextKind.Plan, planGraphIri: buildPlanIri(planName) };
+    }
+    if (isPresent(ruleName)) {
+        return {
+            kind: ChatContextKind.RuleEdit,
+            ruleIri: expandPrefix(`:${decodeRuleRouteName(ruleName)}`),
+        };
+    }
+    return undefined;
+}
+export function useChatPanelSync() {
+    const { chatOpen, open: openChat, close: closeChat } = useChatPanel();
+    const { activeConversation, selectedContext, selectContext } = useChatManagerConnection();
+    const { open: sidebarOpen, setOpen: setSidebarOpen } = useSidebar();
+    const { planName } = useActionPlanRouteState();
+    const { ruleName } = useParams();
+    const { state: locationState } = useLocation();
+    const onRulesOverview = useMatch("/rules") !== null;
+    const fromChat = locationState?.fromChat === true;
+    const persistedContext = activeConversation?.context ?? undefined;
+    const routeContext = useMemo(() => routeChatContext(planName, ruleName), [planName, ruleName]);
+    const contextReady = !routeContext || equals(selectedContext, routeContext);
+    const isSplitEligible = isPresent(routeContext) || (onRulesOverview && isDraftChatContext(persistedContext));
+    const showSplit = isSplitEligible && chatOpen;
+    const chatReady = !chatOpen || contextReady;
+    const wasShowingSplitRef = useRef(false);
+    const previousSidebarOpenRef = useRef(null);
+    useEffect(() => {
+        const { nextSidebarOpen, previousSidebarOpen } = computePlanSplitSidebarSync({
+            showSplit,
+            wasShowingSplit: wasShowingSplitRef.current,
+            sidebarOpen,
+            previousSidebarOpen: previousSidebarOpenRef.current,
+        });
+        if (nextSidebarOpen !== undefined)
+            setSidebarOpen(nextSidebarOpen);
+        previousSidebarOpenRef.current = previousSidebarOpen;
+        wasShowingSplitRef.current = showSplit;
+    }, [showSplit, sidebarOpen, setSidebarOpen]);
+    useEffect(() => {
+        if (fromChat)
+            openChat();
+    }, [fromChat, openChat]);
+    useEffect(() => {
+        if (!chatOpen || !routeContext || equals(persistedContext, routeContext))
+            return;
+        void selectContext(routeContext).catch(() => {
+            toast.error("Couldn't open the chat. Please try again.");
+            closeChat();
+        });
+    }, [chatOpen, closeChat, persistedContext, routeContext, selectContext]);
+    return { splitEligible: isSplitEligible, chatOpen, chatReady, closeChat };
+}

package/dist/hooks/useConversationGraphContext.d.ts

@@ -0,0 +1,13 @@
+import type { ChatUIMessage } from "@manta-eu/client/shared/index";
+import { type JsonLdGraphDocument } from "@manta-eu/client/types/jsonld";
+type ConversationGraphContext = {
+    mergedGraph: JsonLdGraphDocument;
+    graphCount: number;
+    nodeCount: number;
+    sparqlQueries: string[];
+};
+export declare function useConversationGraphContext(messages: ChatUIMessage[], options?: {
+    enabled?: boolean;
+}): ConversationGraphContext;
+export {};
+//# sourceMappingURL=useConversationGraphContext.d.ts.map

package/dist/hooks/useConversationGraphContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationGraphContext.d.ts","sourceRoot":"","sources":["../../src/hooks/useConversationGraphContext.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAA4C,KAAK,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAcnH,KAAK,wBAAwB,GAAG;IAC9B,WAAW,EAAE,mBAAmB,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA0BF,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,aAAa,EAAE,EACzB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAClC,wBAAwB,CA2C1B"}

package/dist/hooks/useConversationGraphContext.js

@@ -0,0 +1,61 @@
+import { isJsonLdGraphDocument, mergeJsonLdGraphs } from "@manta-eu/client/types/jsonld";
+import { isPresent } from "@manta-eu/lib/present";
+import { useMemo } from "react";
+const emptyGraphContext = {
+    mergedGraph: mergeJsonLdGraphs([]),
+    graphCount: 0,
+    nodeCount: 0,
+    sparqlQueries: [],
+};
+function isToolUIPart(part) {
+    return (typeof part === "object" &&
+        part !== null &&
+        "type" in part &&
+        typeof part.type === "string" &&
+        part.type.startsWith("tool-"));
+}
+function extractJsonLdFromToolResult(output) {
+    if (isJsonLdGraphDocument(output)) {
+        return output;
+    }
+    return null;
+}
+export function useConversationGraphContext(messages, options = {}) {
+    const enabled = options.enabled ?? true;
+    return useMemo(() => {
+        if (!enabled)
+            return emptyGraphContext;
+        const graphs = [];
+        const sparqlQueries = [];
+        for (const message of messages) {
+            if (!message.parts)
+                continue;
+            for (const part of message.parts) {
+                if (!isToolUIPart(part))
+                    continue;
+                if (part.state !== "output-available")
+                    continue;
+                const inputObj = (part.input ?? part.args);
+                if (inputObj && typeof inputObj === "object") {
+                    const sparqlQuery = (inputObj.sparql ?? inputObj.query ?? inputObj.sparqlQuery);
+                    if (sparqlQuery && typeof sparqlQuery === "string") {
+                        sparqlQueries.push(sparqlQuery);
+                    }
+                }
+                const jsonLd = extractJsonLdFromToolResult(part.output);
+                if (jsonLd) {
+                    if (isPresent(jsonLd["@graph"])) {
+                        graphs.push(jsonLd);
+                    }
+                }
+            }
+        }
+        const mergedGraph = mergeJsonLdGraphs(graphs);
+        return {
+            mergedGraph,
+            graphCount: graphs.length,
+            nodeCount: mergedGraph["@graph"].length,
+            sparqlQueries,
+        };
+    }, [messages, enabled]);
+}

package/dist/hooks/useConversations.d.ts

@@ -0,0 +1,28 @@
+import type { ListConversationsInput } from "@manta-eu/client/shared/chat-manager";
+type UseConversationsOptions = ListConversationsInput & {
+    enabled?: boolean;
+};
+export declare function useConversations(options?: UseConversationsOptions): {
+    conversations: {
+        id: string;
+        chatIRI: string;
+        title: string;
+        context: {
+            kind: import("@manta-eu/client/shared/agent-types").ChatContextKind.RuleEdit;
+            ruleIri: string;
+        } | {
+            kind: import("@manta-eu/client/shared/agent-types").ChatContextKind.RuleCreate;
+            draftIri: string;
+        } | {
+            kind: import("@manta-eu/client/shared/agent-types").ChatContextKind.Plan;
+            planGraphIri: string;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+    }[];
+    isLoading: boolean;
+    error: Error | undefined;
+    enabled: boolean;
+};
+export {};
+//# sourceMappingURL=useConversations.d.ts.map