@manta-eu/client 0.2.1 → 0.4.0

package/src/shared/action-document.ts

@@ -1,6 +1,9 @@
-import jsonld from "jsonld";
-import { encodeEntity, type Lens, type Schema } from "ldkit";
-import { xsd } from "ldkit/namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { owlNothingIri } from "@manta-eu/rdf-lib/namespaces";
+import { encodeEntity, type Identity, type Lens, type Property, type Schema, type SchemaInterface } from "ldkit";
+import { rdf, xsd } from "ldkit/namespaces";
+import { groupBy, uniq, uniqBy } from "ramda";
+import type { GQLExecuteActionUpdateInput } from "../generated/graphql";
 
 export type DocumentTerm = { value: string; termType: string };
 
@@ -10,47 +13,97 @@ export type DocumentQuad = {
   object: DocumentTerm & { datatype?: { value: string }; language?: string };
 };
 
-export type InsertEntity<S extends Schema> = Parameters<Lens<S>["insert"]>[number];
+type InsertEntity<S extends Schema> = Parameters<Lens<S>["insert"]>[number];
 
-// jsonld keeps the `_:` prefix in a blank node value
-function jsonldTerm(term: DocumentTerm): DocumentTerm {
-  return { termType: term.termType, value: term.termType === "BlankNode" ? `_:${term.value}` : term.value };
+export type ActionSchema = Schema & { "@type": string };
+
+export type Writable<T> = T extends readonly (infer E)[]
+  ? Writable<E>[]
+  : T extends Record<string, unknown>
+    ? { [K in keyof T]?: Writable<T[K]> }
+    : T;
+
+export type ActionEntity<S extends Schema> = Identity &
+  (string extends keyof S ? Record<string, unknown> : Writable<Omit<SchemaInterface<S>, "$id">>);
+
+export type ActionInput = GQLExecuteActionUpdateInput;
+
+const termKey = (term: DocumentTerm): string => (term.termType === "BlankNode" ? `_:${term.value}` : term.value);
+
+const objectKey = ({ object }: DocumentQuad): string =>
+  `${termKey(object)} ${object.datatype?.value ?? ""} ${object.language ?? ""}`;
+
+const oneOrMany = (values: readonly unknown[]): unknown => (values.length === 1 ? values[0] : values);
+
+function literal(object: DocumentQuad["object"]): unknown {
+  const datatype = object.datatype?.value ?? xsd.string;
+
+  if (isPresent(object.language)) return { "@value": object.value, "@language": object.language };
+  if (datatype === xsd.string) return object.value;
+  return { "@value": object.value, "@type": datatype };
 }
 
-function jsonldQuad(quad: DocumentQuad) {
-  const { subject, predicate, object } = quad;
-
-  return {
-    subject: jsonldTerm(subject),
-    predicate: { termType: "NamedNode", value: predicate.value },
-    object:
-      object.termType === "Literal"
-        ? {
-            termType: "Literal",
-            value: object.value,
-            language: object.language,
-            datatype: { value: object.datatype?.value ?? xsd.string },
-          }
-        : jsonldTerm(object),
-    graph: { termType: "DefaultGraph", value: "" },
+export function documentFromQuads(quads: readonly DocumentQuad[], subjectIri: string): Record<string, unknown> {
+  const described = quads.filter(({ subject }) => subject.value === subjectIri || subject.termType === "BlankNode");
+  const bySubject = groupBy((quad: DocumentQuad) => termKey(quad.subject), described);
+  const blankObjects = described.flatMap(({ object }) => (object.termType === "BlankNode" ? [termKey(object)] : []));
+  const shared = new Set(blankObjects.filter((key, index) => blankObjects.indexOf(key) !== index));
+  const labels = new Map<string, string>();
+
+  const label = (key: string): string => {
+    if (!labels.has(key)) labels.set(key, `_:b${labels.size}`);
+    return labels.get(key) ?? key;
   };
+
+  const value = (object: DocumentQuad["object"], path: readonly string[]): unknown => {
+    const key = termKey(object);
+
+    if (object.termType === "Literal") return literal(object);
+    if (object.termType !== "BlankNode") return { "@id": key };
+    if (path.includes(key)) return { "@id": label(key) };
+    return node(key, [...path, key]);
+  };
+
+  const node = (key: string, path: readonly string[]): Record<string, unknown> => {
+    const own = bySubject[key] ?? [];
+    const types = own.filter(({ predicate }) => predicate.value === rdf.type).map(({ object }) => termKey(object));
+    const others = own.filter(({ predicate }) => predicate.value !== rdf.type);
+    const byPredicate = groupBy((quad: DocumentQuad) => quad.predicate.value, others);
+
+    return {
+      ...(shared.has(key) && { "@id": label(key) }),
+      ...(isPresent(types) && { "@type": oneOrMany(uniq(types)) }),
+      ...Object.fromEntries(
+        Object.entries(byPredicate).map(([predicate, values = []]) => [
+          predicate,
+          oneOrMany(uniqBy(objectKey, values).map(({ object }) => value(object, path))),
+        ]),
+      ),
+    };
+  };
+
+  return { "@id": subjectIri, ...node(subjectIri, [subjectIri]) };
 }
 
-export async function documentFromQuads(
-  quads: readonly DocumentQuad[],
-  subjectIri: string,
-): Promise<Record<string, unknown>> {
-  const described = quads.filter(({ subject }) => subject.value === subjectIri || subject.termType === "BlankNode");
-  const flattened = await jsonld.fromRDF(described.map(jsonldQuad));
+export function entityActionDocument<S extends Schema>(schema: S, entity: ActionEntity<S>): Record<string, unknown> {
+  const quads = encodeEntity(schema, entity as unknown as InsertEntity<S>).filter(
+    (quad) => quad.object.termType !== "Variable",
+  );
 
-  return jsonld.frame(flattened, { "@id": subjectIri, "@embed": "@always" });
+  return documentFromQuads(quads, entity.$id);
 }
 
-export function entityActionDocument<S extends Schema>(
+const propertyIri = (definition: Property | string | readonly string[] | undefined): string =>
+  typeof definition === "object" && "@id" in definition ? definition["@id"] : String(definition);
+
+export function entityActionInput<S extends ActionSchema>(
   schema: S,
-  entity: InsertEntity<S>,
-): Promise<Record<string, unknown>> {
-  const quads = encodeEntity(schema, entity).filter((quad) => quad.object.termType !== "Variable");
+  actionShape: string,
+  entity: ActionEntity<S>,
+  cleared: readonly (Exclude<keyof S, "@type"> & string)[] = [],
+): ActionInput {
+  const document = entityActionDocument(schema, entity);
+  const nothing = Object.fromEntries(cleared.map((key) => [propertyIri(schema[key]), { "@id": owlNothingIri }]));
 
-  return documentFromQuads(quads, entity.$id);
+  return { subjectIri: entity.$id, rdfType: schema["@type"], actionShape, properties: { ...document, ...nothing } };
 }

package/src/shared/datastore-id.ts

@@ -17,7 +17,7 @@ export function deriveDatastoreId(organizationName: string, segments: string[]):
   );
 }
 
-// Validated before reaching Infisical/KGC/RDFox since the Keycloak attribute is admin-settable.
+// Validated before reaching Infisical, KGC or the datastore, since the Keycloak attribute is admin-settable.
 const datastoreIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 
 export function isValidDatastoreId(id: string): boolean {

package/src/shared/email.ts

@@ -1,6 +1,9 @@
-import { nco, nmo } from "@manta-eu/ldo/namespaces";
+import { NcoEmailAddressSchema } from "@manta-eu/ldo/schemas/nco";
+import { NmoEmailSchema } from "@manta-eu/ldo/schemas/nmo";
 import { isPresent } from "@manta-eu/lib/present";
+import type { Schema } from "ldkit";
 import { ExecuteAgentActionAdditionDocument, type GQLExecuteAgentActionAdditionMutation } from "../generated/graphql";
+import { entityActionInput } from "./action-document";
 
 export type EmailGraphql = (document: string, variables: Record<string, unknown>) => Promise<unknown>;
 
@@ -16,22 +19,25 @@ export type RenderedEmail = {
 
 export type EmailStart = { ok: true; plan: string } | { ok: false; error: string };
 
-function renderedEmailAddition(terms: RealmEmailTerms, email: RenderedEmail) {
-  return {
-    subjectIri: email.subjectIri,
-    rdfType: nmo.Email,
-    actionShape: terms.emailMessageShape,
-    properties: {
-      "@id": email.subjectIri,
-      "@type": nmo.Email,
-      [nmo.messageFrom]: { "@type": nco.EmailAddress, [nco.emailAddress]: email.from },
-      [nmo.emailTo]: { "@type": nco.EmailAddress, [nco.emailAddress]: email.to },
-      [nmo.messageSubject]: email.subject,
-      [nmo.contentMimeType]: "text/html",
-      [terms.renderedFrom]: { "@id": email.renderedFrom },
-    },
-  };
-}
+const renderedEmailSchema = (terms: RealmEmailTerms) =>
+  ({
+    "@type": NmoEmailSchema["@type"],
+    from: { "@id": NmoEmailSchema.messageFrom["@id"], "@schema": NcoEmailAddressSchema },
+    to: { "@id": NmoEmailSchema.emailTo["@id"], "@schema": NcoEmailAddressSchema },
+    subject: NmoEmailSchema.messageSubject,
+    contentMimeType: NmoEmailSchema.contentMimeType,
+    renderedFrom: { ...NmoEmailSchema.renderedFrom, "@id": terms.renderedFrom },
+  }) as const satisfies Schema;
+
+const renderedEmailAddition = (terms: RealmEmailTerms, email: RenderedEmail) =>
+  entityActionInput(renderedEmailSchema(terms), terms.emailMessageShape, {
+    $id: email.subjectIri,
+    from: { emailAddress: email.from },
+    to: { emailAddress: email.to },
+    subject: email.subject,
+    contentMimeType: "text/html",
+    renderedFrom: email.renderedFrom,
+  });
 
 export async function startRenderedEmail(
   graphql: EmailGraphql,

package/src/shared/memory-citation-sampling.ts

@@ -9,18 +9,18 @@ export function shouldRequestCitations(seed: string, rate: number = memoryCitati
 
 export type CitationRequestTurn = {
   hasPersonalPreload: boolean;
+  hasPersonalRecall: boolean;
   hasSharedSections: boolean;
   seed: string;
 };
 
 export type CitationDecision =
   | { requested: false; reason: "none" }
-  | { requested: true; reason: "personal" | "sampled" };
+  | { requested: true; reason: "personal" | "recalled" | "sampled" };
 
 export function citationDecisionForTurn(turn: CitationRequestTurn, rate?: number): CitationDecision {
   if (turn.hasPersonalPreload) return { requested: true, reason: "personal" };
-  if (turn.hasSharedSections && shouldRequestCitations(turn.seed, rate)) {
-    return { requested: true, reason: "sampled" };
-  }
-  return { requested: false, reason: "none" };
+  if (!turn.hasPersonalRecall && !turn.hasSharedSections) return { requested: false, reason: "none" };
+  if (!shouldRequestCitations(turn.seed, rate)) return { requested: false, reason: "none" };
+  return { requested: true, reason: turn.hasPersonalRecall ? "recalled" : "sampled" };
 }

package/src/shared/memory-diversity.ts

@@ -7,7 +7,7 @@ export type DiversityCandidate = {
   description?: string | null;
 };
 
-const tokenPattern = /[a-z0-9]+/g;
+const tokenPattern = /[\p{L}\p{N}]+/gu;
 
 const minimumTokenLength = 3;
 

package/src/shared/memory-keyword-recall.ts

@@ -5,6 +5,8 @@ export const rankFusionConstant = 60;
 
 export const maxKeywordTerms = 8;
 
+export const maxKeywordTermLength = 40;
+
 export type KeywordCandidate = DiversityCandidate & { iri: string };
 
 // A term feeds a SPARQL CONTAINS that admits rows, so a stray function word like "the" would widen the pool to the
@@ -103,7 +105,7 @@ const stopWords = new Set([
 
 export function keywordTerms(text: string, limit: number = maxKeywordTerms): string[] {
   return [...memoryTokens({ label: text })]
-    .filter((token) => !stopWords.has(token))
+    .filter((token) => !stopWords.has(token) && token.length <= maxKeywordTermLength)
     .sort((a, b) => b.length - a.length || a.localeCompare(b))
     .slice(0, limit);
 }

package/src/shared/rdf-namespaces.ts

@@ -3,12 +3,8 @@ import {
   expandPrefix as expandPrefixIri,
   iriLocalName as iriLocalNameValue,
   iriNamespace as iriNamespaceValue,
-  rdfoxDefaultBaseIri as rdfoxDefaultBaseIriValue,
-  shaclGraphIri as shaclGraphIriValue,
 } from "@manta-eu/rdf-lib/namespaces";
 
-export const rulesGraphIri = `${rdfoxDefaultBaseIriValue}rules`;
-
 // KGC uploads the realm ontology here (kgc/kgc/realms/lib/ontology.py: realm_base + "ontology").
 export const ontologyGraphIri = expandPrefixIri(":ontology");
 
@@ -19,8 +15,6 @@ export const writeLifecycle = {
   createOnly: expandPrefixIri("relay:CreateOnly"),
 };
 
-export const nonDataGraphIris = [ontologyGraphIri, shaclGraphIriValue, rulesGraphIri];
-
 export function mintInstanceIri(classIri: string, localId: string): string {
   return `${iriNamespaceValue(classIri)}${encodeIriLocalNameValue(`${iriLocalNameValue(classIri)}_${localId}`)}`;
 }
@@ -33,7 +27,7 @@ export {
   encodeIriUnsafeChars,
   expandPrefix,
   formatEntityName,
-  formatIriForRdfox,
+  formatIriForSparql,
   getNamespaceValues,
   isFullIri,
   isValidFullIri,
@@ -52,8 +46,7 @@ export {
   nfo,
   parseEntityUri,
   prependMissingSparqlPrefixes,
-  rdfoxDefaultBaseIri,
-  shaclGraphIri,
+  shaclGraph,
   sh,
   toTurtlePrefixes,
   validateFullIri,

package/src/shared/tools/coercers.ts

@@ -1,5 +1,5 @@
 import type {
-  RDFoxFactsOutput,
+  QueryKnowledgeGraphOutput,
   ShowEntitiesOutput,
   SparqlJsonResults,
   ToolErrorResult,
@@ -43,8 +43,11 @@ function coerceWith<T>(
   return { is_error: true, content: `Unexpected ${toolName} output format` };
 }
 
-function coerceRDFoxFactsOutput(raw: unknown): RDFoxFactsOutput {
-  return coerceWith<RDFoxFactsOutput>("getRDFoxFacts", raw, [isSparqlJsonResults, isJsonLdGraphDocument]);
+function coerceQueryKnowledgeGraphOutput(raw: unknown): QueryKnowledgeGraphOutput {
+  return coerceWith<QueryKnowledgeGraphOutput>("queryKnowledgeGraph", raw, [
+    isSparqlJsonResults,
+    isJsonLdGraphDocument,
+  ]);
 }
 
 export function isShowEntitiesResult(data: unknown): data is Exclude<ShowEntitiesOutput, ToolErrorResult> {
@@ -62,7 +65,7 @@ function coerceShowEntitiesOutput(raw: unknown): ShowEntitiesOutput {
 }
 
 const coercers: Partial<Record<ToolName, ToolOutputCoercer<ToolName>>> = {
-  getRDFoxFacts: coerceRDFoxFactsOutput as ToolOutputCoercer<"getRDFoxFacts">,
+  queryKnowledgeGraph: coerceQueryKnowledgeGraphOutput as ToolOutputCoercer<"queryKnowledgeGraph">,
   showEntities: coerceShowEntitiesOutput as ToolOutputCoercer<"showEntities">,
 };
 

package/src/shared/tools/index.ts

@@ -13,22 +13,22 @@ export type {
   ActionPlanShowcaseInput,
   ActionPlanShowcaseOutput,
   ActionPlanStatus,
-  AddRDFoxFactsInput,
-  AddRDFoxFactsOutput,
+  AddFactsInput,
+  AddFactsOutput,
   CancelScheduleInput,
   CancelScheduleOutput,
   ExecuteActionPlanInput,
   ExecuteActionPlanOutput,
-  ExplainRDFoxRulesInput,
-  ExplainRDFoxRulesOutput,
+  ExplainFactToolInput,
+  ExplainFactToolOutput,
   GenerateChartInput,
   GenerateChartOutput,
-  GetRDFoxRulesInput,
-  GetRDFoxRulesOutput,
+  GetRulesInput,
+  GetRulesOutput,
   ListScheduledTasksInput,
   ListScheduledTasksOutput,
-  RDFoxFactsInput,
-  RDFoxFactsOutput,
+  QueryKnowledgeGraphInput,
+  QueryKnowledgeGraphOutput,
   ScheduleTaskInput,
   ScheduleTaskOutput,
   ShowEntitiesInput,

package/src/shared/tools/metadata.ts

@@ -6,30 +6,30 @@ import { iriLocalName } from "../rdf-namespaces";
 import type { ToolMetadata, ToolName } from "./types";
 
 export const toolMetadata: ToolMetadata = {
-  getRDFoxFacts: {
-    name: "getRDFoxFacts",
-    category: "rdfox",
+  queryKnowledgeGraph: {
+    name: "queryKnowledgeGraph",
+    category: "knowledge-graph",
     humanName: "Query knowledge base",
-    description: "Retrieve facts from RDFox knowledge base using SPARQL",
+    description: "Retrieve facts from the knowledge graph using SPARQL",
     getHumanName: (input) => {
       return input?.humanIntent || "Querying...";
     },
   },
-  addRDFoxFacts: {
-    name: "addRDFoxFacts",
-    category: "rdfox",
+  addFacts: {
+    name: "addFacts",
+    category: "knowledge-graph",
     humanName: "Add facts",
-    description: "Add facts to RDFox knowledge base as Turtle",
+    description: "Add facts to the knowledge graph as Turtle",
     getHumanName: (input) => {
       return input?.humanIntent || "Adding facts...";
     },
   },
-  getRDFoxRules: {
-    name: "getRDFoxRules",
-    category: "rdfox",
+  getRules: {
+    name: "getRules",
+    category: "knowledge-graph",
     humanName: "Check rules",
     description:
-      "Retrieve Datalog rules from RDFox with optional filters (named graph, rdf:type, limit) to avoid context overflow",
+      "Retrieve Datalog rules from the knowledge graph with optional filters (named graph, rdf:type, limit) to avoid context overflow",
     getHumanName: (input) => {
       const parts: string[] = [];
       if (input?.namedGraphIri) parts.push(`plan: ${input.namedGraphIri}`);
@@ -38,9 +38,9 @@ export const toolMetadata: ToolMetadata = {
       return `Checking rules ${parts.join(" + ")}`;
     },
   },
-  explainRDFoxRules: {
-    name: "explainRDFoxRules",
-    category: "rdfox",
+  explainFact: {
+    name: "explainFact",
+    category: "knowledge-graph",
     humanName: "Explain reasoning",
     description: "Explain how facts are derived using rules",
     getHumanName: () => "Explaining reasoning...",
@@ -88,20 +88,20 @@ export const toolMetadata: ToolMetadata = {
       return input?.namedGraphIri ? `Execute plan: ${input.namedGraphIri}` : "Executing action plan...";
     },
   },
-  manageRDFoxRules: {
-    name: "manageRDFoxRules",
-    category: "rdfox",
+  manageRules: {
+    name: "manageRules",
+    category: "knowledge-graph",
     humanName: "Manage rules",
-    description: "Add, change, or remove Datalog rules in RDFox knowledge base",
+    description: "Add, change, or remove Datalog rules in the knowledge graph",
     getHumanName: (input) => {
       return input?.humanIntent || "Managing rules...";
     },
   },
-  manageRDFoxFacts: {
-    name: "manageRDFoxFacts",
-    category: "rdfox",
+  manageFacts: {
+    name: "manageFacts",
+    category: "knowledge-graph",
     humanName: "Manage facts",
-    description: "Add, change facts in RDFox knowledge",
+    description: "Add or change facts in the knowledge graph",
     getHumanName: (input) => {
       return input?.humanIntent || "Managing facts...";
     },

package/src/shared/tools/types.ts

@@ -10,17 +10,17 @@ export type { TestTripleInput };
 export type SparqlJsonBinding = SparqlBinding;
 
 export type ToolName =
-  | "getRDFoxFacts"
-  | "addRDFoxFacts"
-  | "getRDFoxRules"
-  | "explainRDFoxRules"
+  | "queryKnowledgeGraph"
+  | "addFacts"
+  | "getRules"
+  | "explainFact"
   | "scheduleTask"
   | "listScheduledTasks"
   | "cancelSchedule"
   | "generateChart"
   | "executeActionPlan"
-  | "manageRDFoxRules"
-  | "manageRDFoxFacts"
+  | "manageRules"
+  | "manageFacts"
   | "actionPlanShowcase"
   | "showEntities"
   | "checkAutoPilotStatus"
@@ -28,7 +28,7 @@ export type ToolName =
   | "markAsLowRisk"
   | "readUploadedFile";
 
-export type ToolCategory = "rdfox" | "scheduler" | "charts" | "action" | "auto-pilot";
+export type ToolCategory = "knowledge-graph" | "scheduler" | "charts" | "action" | "auto-pilot";
 
 export type ToolInputSchema<T = unknown> = z.ZodSchema<T>;
 
@@ -39,36 +39,36 @@ export type ToolErrorResult = {
   content: string;
 };
 
-export type RDFoxFactsInput = {
+export type QueryKnowledgeGraphInput = {
   humanIntent: string;
   sparql: string;
   keepPrefixes?: boolean;
 };
 
-export type RDFoxFactsOutput = JsonLdGraphDocument | SparqlJsonResults | ToolErrorResult;
+export type QueryKnowledgeGraphOutput = JsonLdGraphDocument | SparqlJsonResults | ToolErrorResult;
 
-export type AddRDFoxFactsInput = {
+export type AddFactsInput = {
   facts: string;
   humanIntent: string;
 };
 
-export type AddRDFoxFactsOutput = string | ToolErrorResult;
+export type AddFactsOutput = string | ToolErrorResult;
 
-export type GetRDFoxRulesInput = {
+export type GetRulesInput = {
   namedGraphIri?: string;
   rdfTypes?: string[];
   limit?: number;
 };
 
-export type GetRDFoxRulesOutputSuccess = {
+export type GetRulesOutputSuccess = {
   rules: string[] | string | Record<string, unknown>[]; // TODO: standardize on RuleInfo type
   totalCount: number;
   truncated?: boolean;
 };
 
-export type GetRDFoxRulesOutput = GetRDFoxRulesOutputSuccess | ToolErrorResult;
+export type GetRulesOutput = GetRulesOutputSuccess | ToolErrorResult;
 
-export type ExplainRDFoxRulesInput = {
+export type ExplainFactToolInput = {
   subject: string;
   predicate?: string;
   object: string;
@@ -76,7 +76,7 @@ export type ExplainRDFoxRulesInput = {
 
 export type ToolObjectOutput = object | ToolErrorResult;
 
-export type ExplainRDFoxRulesOutput = ToolObjectOutput;
+export type ExplainFactToolOutput = ToolObjectOutput;
 
 export type ScheduleTaskInput = {
   when: "scheduled" | "delayed" | "cron";
@@ -151,7 +151,7 @@ export type ExecuteActionPlanOutput =
     }
   | ToolErrorResult;
 
-export type ManageRDFoxRulesInput = {
+export type ManageRulesInput = {
   humanIntent: string;
   operation: "add" | "change" | "remove";
   ruleIri?: string;
@@ -161,17 +161,17 @@ export type ManageRDFoxRulesInput = {
   dryRun?: boolean;
   stageOnly?: boolean;
 };
-export type ManageRDFoxRulesSuccess = {
+export type ManageRulesSuccess = {
   success: true;
   ruleIri: string;
   parsedRule: DatalogRule | null;
   content: string;
 };
 
-export type ManageRDFoxRulesOutput =
-  | (ManageRDFoxRulesSuccess & { dryRun: true })
-  | (ManageRDFoxRulesSuccess & { staged: true })
-  | (ManageRDFoxRulesSuccess & {
+export type ManageRulesOutput =
+  | (ManageRulesSuccess & { dryRun: true })
+  | (ManageRulesSuccess & { staged: true })
+  | (ManageRulesSuccess & {
       ruleText: string;
       inferenceVerified: boolean;
       inferenceVerification: InferenceVerificationResult | null;
@@ -183,7 +183,7 @@ export type ManageRDFoxRulesOutput =
     })
   | ToolErrorResult;
 
-export type ManageRDFoxFactsInput = {
+export type ManageFactsInput = {
   humanIntent: string;
   facts: string;
   namedGraphIri?: string;
@@ -191,7 +191,7 @@ export type ManageRDFoxFactsInput = {
   etag?: string;
 };
 
-export type ManageRDFoxFactsOutput =
+export type ManageFactsOutput =
   | {
       content: string;
       is_error: boolean;
@@ -265,17 +265,17 @@ export type AutoPilotOutput = ({ success: true } & AutoPilotActionPlan) | ToolEr
 export type CheckAutoPilotStatusOutput = AutoPilotActionPlan | ToolErrorResult;
 
 export type ToolDefinitions = {
-  getRDFoxFacts: ToolDefinition<RDFoxFactsInput, RDFoxFactsOutput>;
-  addRDFoxFacts: ToolDefinition<AddRDFoxFactsInput, AddRDFoxFactsOutput>;
-  getRDFoxRules: ToolDefinition<GetRDFoxRulesInput, GetRDFoxRulesOutput>;
-  explainRDFoxRules: ToolDefinition<ExplainRDFoxRulesInput, ExplainRDFoxRulesOutput>;
+  queryKnowledgeGraph: ToolDefinition<QueryKnowledgeGraphInput, QueryKnowledgeGraphOutput>;
+  addFacts: ToolDefinition<AddFactsInput, AddFactsOutput>;
+  getRules: ToolDefinition<GetRulesInput, GetRulesOutput>;
+  explainFact: ToolDefinition<ExplainFactToolInput, ExplainFactToolOutput>;
   scheduleTask: ToolDefinition<ScheduleTaskInput, ScheduleTaskOutput>;
   listScheduledTasks: ToolDefinition<ListScheduledTasksInput, ListScheduledTasksOutput>;
   cancelSchedule: ToolDefinition<CancelScheduleInput, CancelScheduleOutput>;
   generateChart: ToolDefinition<GenerateChartInput, GenerateChartOutput>;
   executeActionPlan: ToolDefinition<ExecuteActionPlanInput, ExecuteActionPlanOutput>;
-  manageRDFoxRules: ToolDefinition<ManageRDFoxRulesInput, ManageRDFoxRulesOutput>;
-  manageRDFoxFacts: ToolDefinition<ManageRDFoxFactsInput, ManageRDFoxFactsOutput>;
+  manageRules: ToolDefinition<ManageRulesInput, ManageRulesOutput>;
+  manageFacts: ToolDefinition<ManageFactsInput, ManageFactsOutput>;
   actionPlanShowcase: ToolDefinition<ActionPlanShowcaseInput, ActionPlanShowcaseOutput>;
   showEntities: ToolDefinition<ShowEntitiesInput, ShowEntitiesOutput>;
   checkAutoPilotStatus: ToolDefinition<AutoPilotInput, CheckAutoPilotStatusOutput>;

package/src/shared/writable-shape-query.ts

@@ -1,6 +1,6 @@
 import { DataFactory } from "ldkit/rdf";
 import { SELECT } from "ldkit/sparql";
-import { sh, shaclGraphIri, writeLifecycle } from "./rdf-namespaces";
+import { sh, shaclGraph, writeLifecycle } from "./rdf-namespaces";
 
 const dataFactory = new DataFactory();
 const property = dataFactory.namedNode(sh.property);
@@ -12,7 +12,7 @@ export function buildActionShapePropertyQuery(actionShapeIris: string[]): string
   const actionShapes = actionShapeIris.map((iri) => dataFactory.namedNode(iri));
 
   return SELECT`DISTINCT ?actionShape ?parent ?path ?node ?flag`.WHERE`
-    GRAPH ${dataFactory.namedNode(shaclGraphIri)} {
+    GRAPH ${dataFactory.namedNode(shaclGraph)} {
       VALUES ?actionShape { ${actionShapes} }
       ?actionShape (${property}/${node})* ?parent .
       ?parent ${property} ?propertyShape .