@manta-eu/client 0.1.0

package/dist/shared/memory-volatility.js

@@ -0,0 +1,55 @@
+import { msPerDay, parseMemoryDate } from "./memory-dates.js";
+export const memoryVolatilities = ["stable", "slow", "volatile"];
+export const volatilityRules = {
+    stable: { trustDays: null, maxImportance: 5 },
+    slow: { trustDays: 90, maxImportance: 3 },
+    volatile: { trustDays: 7, maxImportance: 2 },
+};
+export const defaultMemoryVolatility = "slow";
+export function isMemoryVolatility(value) {
+    return typeof value === "string" && memoryVolatilities.includes(value);
+}
+export function normalizeVolatility(value) {
+    return isMemoryVolatility(value) ? value : defaultMemoryVolatility;
+}
+export function volatilityTrustDays(volatility) {
+    return volatilityRules[normalizeVolatility(volatility)].trustDays;
+}
+export function maxImportanceForVolatility(volatility) {
+    return volatilityRules[normalizeVolatility(volatility)].maxImportance;
+}
+export const volatilityInferenceSlack = 1.5;
+export function inferVolatility(memoryTrustedUntil, since) {
+    if (memoryTrustedUntil == null)
+        return "stable";
+    const horizon = parseMemoryDate(memoryTrustedUntil);
+    const from = parseMemoryDate(since);
+    if (horizon == null || from == null)
+        return defaultMemoryVolatility;
+    const spanDays = (horizon.getTime() - from.getTime()) / msPerDay;
+    const volatileDays = volatilityRules.volatile.trustDays ?? 0;
+    return spanDays <= volatileDays * volatilityInferenceSlack ? "volatile" : defaultMemoryVolatility;
+}
+export function isDeadlineDerivedHorizon(memoryTrustedUntil, memoryValidUntil) {
+    const horizon = parseMemoryDate(memoryTrustedUntil);
+    const deadline = parseMemoryDate(memoryValidUntil);
+    return horizon != null && deadline != null && horizon.getTime() === deadline.getTime();
+}
+export function importanceCeilingFor(memory) {
+    return isDeadlineDerivedHorizon(memory.memoryTrustedUntil, memory.memoryValidUntil)
+        ? maxImportanceForVolatility("stable")
+        : maxImportanceForVolatility(inferVolatility(memory.memoryTrustedUntil, memory.extractedAt));
+}
+export function capHorizonByDeadline(horizon, memoryValidUntil, now = new Date()) {
+    const deadline = memoryValidUntil != null && new Date(memoryValidUntil) > now ? memoryValidUntil : null;
+    if (deadline == null)
+        return horizon;
+    if (horizon == null)
+        return deadline;
+    return new Date(deadline) < new Date(horizon) ? deadline : horizon;
+}
+export function resolveTrustedUntil(volatility, memoryValidUntil, now = new Date()) {
+    const days = volatilityTrustDays(volatility);
+    const fromVolatility = days != null ? new Date(now.getTime() + days * msPerDay).toISOString() : null;
+    return capHorizonByDeadline(fromVolatility, memoryValidUntil, now);
+}

package/dist/shared/message-utils.d.ts

@@ -0,0 +1,12 @@
+import type { PageContext } from "./page-context.js";
+import type { ChatUIMessage } from "./index.js";
+import type { OperatorAllowedModel } from "./model.js";
+import type { FileUIPart } from "ai";
+export type CreateUserMessageArgs = {
+    text: string;
+    fileParts?: FileUIPart[];
+    pageContext?: PageContext;
+    model?: OperatorAllowedModel;
+};
+export declare function createUserMessage(args: CreateUserMessageArgs): ChatUIMessage;
+//# sourceMappingURL=message-utils.d.ts.map

package/dist/shared/message-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-utils.d.ts","sourceRoot":"","sources":["../../src/shared/message-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAGrC,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,UAAU,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,KAAK,CAAC,EAAE,oBAAoB,CAAC;CAC9B,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,qBAAqB,GAAG,aAAa,CAsB5E"}

package/dist/shared/message-utils.js

@@ -0,0 +1,22 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { v7 as uuidv7 } from "uuid";
+export function createUserMessage(args) {
+    const { text, fileParts, pageContext, model } = args;
+    const parts = [];
+    if (isPresent(fileParts)) {
+        parts.push(...fileParts);
+    }
+    if (text) {
+        parts.push({ type: "text", text });
+    }
+    return {
+        id: uuidv7(),
+        role: "user",
+        parts,
+        metadata: {
+            createdAt: new Date().toISOString(),
+            ...(pageContext && { pageContext }),
+            ...(model && { model }),
+        },
+    };
+}

package/dist/shared/model.d.ts

@@ -0,0 +1,165 @@
+export declare const opus_5 = "claude-opus-5";
+export declare const sonnet_4_5 = "claude-sonnet-4-5-20250929";
+export declare const haiku_4_5 = "claude-haiku-4-5-20251001";
+export declare const vllmPrimaryModel = "vllm-primary";
+export declare const vertexClaudeModel = "vertex-claude";
+export declare const anthropicPrimaryModel = "claude-opus-5";
+export declare const anthropicSupportedMimeTypes: readonly string[];
+export declare const vllmSupportedMimeTypes: readonly string[];
+export declare const modelOptions: readonly [{
+    readonly id: "claude-opus-5";
+    readonly label: "Claude Opus";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+}, {
+    readonly id: "claude-sonnet-4-5-20250929";
+    readonly label: "Claude Sonnet";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+}, {
+    readonly id: "claude-haiku-4-5-20251001";
+    readonly label: "Claude Haiku";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: false;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+}, {
+    readonly id: "vllm-primary";
+    readonly label: "Manta LLM";
+    readonly provider: "vllm";
+    readonly contextWindow: 262144;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: false;
+}, {
+    readonly id: "vertex-claude";
+    readonly label: "Claude (Vertex AI)";
+    readonly provider: "google-vertex-anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+}];
+export type MantaModelId = (typeof modelOptions)[number]["id"];
+export declare const getModelMetaById: (modelId: MantaModelId) => {
+    readonly id: "claude-opus-5";
+    readonly label: "Claude Opus";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+} | {
+    readonly id: "claude-sonnet-4-5-20250929";
+    readonly label: "Claude Sonnet";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+} | {
+    readonly id: "claude-haiku-4-5-20251001";
+    readonly label: "Claude Haiku";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: false;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+} | {
+    readonly id: "vllm-primary";
+    readonly label: "Manta LLM";
+    readonly provider: "vllm";
+    readonly contextWindow: 262144;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: false;
+} | {
+    readonly id: "vertex-claude";
+    readonly label: "Claude (Vertex AI)";
+    readonly provider: "google-vertex-anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+};
+export declare const getSupportedMimeTypes: (modelId: MantaModelId) => readonly string[];
+export declare function requiresSingleSystemMessage(modelId: MantaModelId): boolean;
+export declare const isValidModelId: (value: unknown) => value is MantaModelId;
+export declare const operatorModelOptions: ({
+    readonly id: "claude-opus-5";
+    readonly label: "Claude Opus";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+} | {
+    readonly id: "claude-sonnet-4-5-20250929";
+    readonly label: "Claude Sonnet";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+} | {
+    readonly id: "vllm-primary";
+    readonly label: "Manta LLM";
+    readonly provider: "vllm";
+    readonly contextWindow: 262144;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: false;
+} | {
+    readonly id: "vertex-claude";
+    readonly label: "Claude (Vertex AI)";
+    readonly provider: "google-vertex-anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+})[];
+export type OperatorAllowedModel = (typeof operatorModelOptions)[number]["id"];
+export declare function isOperatorAllowedModel(value: unknown): value is OperatorAllowedModel;
+export type AllowedModels = readonly [MantaModelId, ...MantaModelId[]];
+export declare function getMinimumContextWindow(allowedModels: AllowedModels): number;
+export declare function operatorModelOptionsFor(allowedModels: readonly MantaModelId[]): ({
+    readonly id: "claude-opus-5";
+    readonly label: "Claude Opus";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+} | {
+    readonly id: "claude-sonnet-4-5-20250929";
+    readonly label: "Claude Sonnet";
+    readonly provider: "anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+} | {
+    readonly id: "vllm-primary";
+    readonly label: "Manta LLM";
+    readonly provider: "vllm";
+    readonly contextWindow: 262144;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: false;
+} | {
+    readonly id: "vertex-claude";
+    readonly label: "Claude (Vertex AI)";
+    readonly provider: "google-vertex-anthropic";
+    readonly contextWindow: 200000;
+    readonly isOperatorAllowed: true;
+    readonly supportedMimeTypes: readonly string[];
+    readonly supportsPromptCaching: true;
+})[];
+//# sourceMappingURL=model.d.ts.map

package/dist/shared/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/shared/model.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM,kBAA0C,CAAC;AAC9D,eAAO,MAAM,UAAU,+BAAuD,CAAC;AAC/E,eAAO,MAAM,SAAS,8BAAsD,CAAC;AAC7E,eAAO,MAAM,gBAAgB,iBAAyC,CAAC;AACvE,eAAO,MAAM,iBAAiB,kBAA0C,CAAC;AAEzE,eAAO,MAAM,qBAAqB,kBAAS,CAAC;AAE5C,eAAO,MAAM,2BAA2B,EAAE,SAAS,MAAM,EAMxD,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAA2D,CAAC;AAEhH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDf,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAI/D,eAAO,MAAM,gBAAgB,GAAI,SAAS,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQrD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,SAAS,YAAY,sBAE1D,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAE1E;AAGD,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,YAExD,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAkD,CAAC;AAEpF,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAE/E,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAEpF;AAED,MAAM,MAAM,aAAa,GAAG,SAAS,CAAC,YAAY,EAAE,GAAG,YAAY,EAAE,CAAC,CAAC;AAEvE,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,aAAa,GAAG,MAAM,CAE5E;AAED,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,SAAS,YAAY,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI7E"}

package/dist/shared/model.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+export const opus_5 = "claude-opus-5";
+export const sonnet_4_5 = "claude-sonnet-4-5-20250929";
+export const haiku_4_5 = "claude-haiku-4-5-20251001";
+export const vllmPrimaryModel = "vllm-primary";
+export const vertexClaudeModel = "vertex-claude";
+export const anthropicPrimaryModel = opus_5;
+export const anthropicSupportedMimeTypes = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+    "application/pdf",
+];
+export const vllmSupportedMimeTypes = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+export const modelOptions = [
+    {
+        id: opus_5,
+        label: "Claude Opus",
+        provider: "anthropic",
+        contextWindow: 200_000,
+        isOperatorAllowed: true,
+        supportedMimeTypes: anthropicSupportedMimeTypes,
+        supportsPromptCaching: true,
+    },
+    {
+        id: sonnet_4_5,
+        label: "Claude Sonnet",
+        provider: "anthropic",
+        contextWindow: 200_000,
+        isOperatorAllowed: true,
+        supportedMimeTypes: anthropicSupportedMimeTypes,
+        supportsPromptCaching: true,
+    },
+    {
+        id: haiku_4_5,
+        label: "Claude Haiku",
+        provider: "anthropic",
+        contextWindow: 200_000,
+        isOperatorAllowed: false,
+        supportedMimeTypes: anthropicSupportedMimeTypes,
+        supportsPromptCaching: true,
+    },
+    {
+        id: vllmPrimaryModel,
+        label: "Manta LLM",
+        provider: "vllm",
+        contextWindow: 262_144,
+        isOperatorAllowed: true,
+        supportedMimeTypes: vllmSupportedMimeTypes,
+        supportsPromptCaching: false,
+    },
+    {
+        id: vertexClaudeModel,
+        label: "Claude (Vertex AI)",
+        provider: "google-vertex-anthropic",
+        // A floor, not the exact window: the model behind this id is whatever GOOGLE_VERTEX_MODEL
+        // names, and which Claude generations a project can reach depends on its pinned region.
+        contextWindow: 200_000,
+        isOperatorAllowed: true,
+        supportedMimeTypes: anthropicSupportedMimeTypes,
+        supportsPromptCaching: true,
+    },
+];
+const modelById = new Map(modelOptions.map((m) => [m.id, m]));
+export const getModelMetaById = (modelId) => {
+    const meta = modelById.get(modelId);
+    if (!meta) {
+        throw new Error(`Unknown model ID: ${modelId}`);
+    }
+    return meta;
+};
+export const getSupportedMimeTypes = (modelId) => {
+    return getModelMetaById(modelId).supportedMimeTypes;
+};
+export function requiresSingleSystemMessage(modelId) {
+    return !getModelMetaById(modelId).supportsPromptCaching;
+}
+const validModelSchema = z.enum(modelOptions.map((m) => m.id));
+export const isValidModelId = (value) => {
+    return validModelSchema.safeParse(value).success;
+};
+export const operatorModelOptions = modelOptions.filter((m) => m.isOperatorAllowed);
+export function isOperatorAllowedModel(value) {
+    return isValidModelId(value) && getModelMetaById(value).isOperatorAllowed;
+}
+export function getMinimumContextWindow(allowedModels) {
+    return Math.min(...allowedModels.map((modelId) => getModelMetaById(modelId).contextWindow));
+}
+export function operatorModelOptionsFor(allowedModels) {
+    const allowed = new Set(allowedModels);
+    return operatorModelOptions.filter((model) => allowed.has(model.id));
+}

package/dist/shared/org-roles.d.ts

@@ -0,0 +1,11 @@
+import type { Capability } from "./permissions.js";
+export type OrgRoleDefinition = {
+    readonly id: string;
+    readonly groupName: string;
+    readonly label: string;
+    readonly capabilities: readonly Capability[];
+};
+export declare const orgAdminRole: OrgRoleDefinition;
+export declare const plainMemberRole = "user";
+export declare function findOrgRole(roles: readonly OrgRoleDefinition[], id: string): OrgRoleDefinition | undefined;
+//# sourceMappingURL=org-roles.d.ts.map

package/dist/shared/org-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org-roles.d.ts","sourceRoot":"","sources":["../../src/shared/org-roles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,SAAS,UAAU,EAAE,CAAC;CAC9C,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,iBAK1B,CAAC;AAEF,eAAO,MAAM,eAAe,SAAS,CAAC;AAEtC,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAE1G"}

package/dist/shared/org-roles.js

@@ -0,0 +1,10 @@
+export const orgAdminRole = {
+    id: "admin",
+    groupName: "Admins",
+    label: "Admin",
+    capabilities: ["team:manage", "org:settings", "org:integrations"],
+};
+export const plainMemberRole = "user";
+export function findOrgRole(roles, id) {
+    return roles.find((role) => role.id === id);
+}

package/dist/shared/page-context.d.ts

@@ -0,0 +1,7 @@
+import type { IRI } from "@manta-eu/rdf-lib/namespaces";
+/** The entities a screen is showing, so the agent can answer about what the user is looking at. */
+export type PageContext = {
+    iris: IRI[];
+    typenames: string[];
+};
+//# sourceMappingURL=page-context.d.ts.map

package/dist/shared/page-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-context.d.ts","sourceRoot":"","sources":["../../src/shared/page-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,8BAA8B,CAAC;AAExD,mGAAmG;AACnG,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC"}

package/dist/shared/page-context.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/permissions.d.ts

@@ -0,0 +1,9 @@
+export declare const capabilities: readonly ["team:manage", "org:settings", "org:integrations"];
+export type Capability = (typeof capabilities)[number];
+export declare function isCapability(value: string): value is Capability;
+export type CapabilityPrincipal = {
+    isOperator: boolean;
+    isOrgAdmin: boolean;
+};
+export declare function hasCapability(principal: CapabilityPrincipal, capability: Capability): boolean;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/shared/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../src/shared/permissions.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,8DAA+D,CAAC;AAEzF,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAE/D;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,wBAAgB,aAAa,CAAC,SAAS,EAAE,mBAAmB,EAAE,UAAU,EAAE,UAAU,GAAG,OAAO,CAG7F"}

package/dist/shared/permissions.js

@@ -0,0 +1,10 @@
+import { orgAdminRole } from "./org-roles.js";
+export const capabilities = ["team:manage", "org:settings", "org:integrations"];
+export function isCapability(value) {
+    return capabilities.some((candidate) => candidate === value);
+}
+export function hasCapability(principal, capability) {
+    if (principal.isOperator)
+        return true;
+    return principal.isOrgAdmin && orgAdminRole.capabilities.includes(capability);
+}

package/dist/shared/questionnaire.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const requestUserInputToolName = "requestUserInput";
+export declare const requestUserInputToolPartType: "tool-requestUserInput";
+export declare const questionnaireInputSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        header: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+            recommended: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const questionnaireOutputSchema: z.ZodObject<{
+    answers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        questionId: z.ZodString;
+        source: z.ZodLiteral<"option">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        questionId: z.ZodString;
+        source: z.ZodLiteral<"other">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        questionId: z.ZodString;
+        source: z.ZodLiteral<"skipped">;
+    }, z.core.$strip>], "source">>;
+}, z.core.$strip>;
+export type QuestionnaireInput = z.infer<typeof questionnaireInputSchema>;
+export type QuestionnaireOutput = z.infer<typeof questionnaireOutputSchema>;
+//# sourceMappingURL=questionnaire.d.ts.map

package/dist/shared/questionnaire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"questionnaire.d.ts","sourceRoot":"","sources":["../../src/shared/questionnaire.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,wBAAwB,qBAAqB,CAAC;AAC3D,eAAO,MAAM,4BAA4B,yBAA8C,CAAC;AAgCxF,eAAO,MAAM,wBAAwB;;;;;;;;;;;iBAgBjC,CAAC;AAmBL,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/shared/questionnaire.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export const requestUserInputToolName = "requestUserInput";
+export const requestUserInputToolPartType = `tool-${requestUserInputToolName}`;
+const questionnaireOptionSchema = z.object({
+    label: z.string().trim().min(1).max(40).describe("Short user-facing option label"),
+    description: z.string().trim().min(1).max(120).describe("One sentence explaining the option"),
+    recommended: z.boolean().optional().describe("Whether this is the recommended option"),
+});
+const questionnaireQuestionSchema = z
+    .object({
+    id: z
+        .string()
+        .trim()
+        .regex(/^[a-z][a-z0-9_]*$/)
+        .describe("Stable snake_case identifier for mapping the answer"),
+    header: z.string().trim().min(1).max(24).describe("Short heading of one to four words"),
+    question: z.string().trim().min(1).max(200).describe("Single-sentence question shown to the user"),
+    options: z
+        .array(questionnaireOptionSchema)
+        .min(1)
+        .max(4)
+        .describe("One to four mutually exclusive predefined answers"),
+})
+    .superRefine(({ options }, context) => {
+    if (options.filter(({ recommended }) => recommended).length <= 1)
+        return;
+    context.addIssue({
+        code: "custom",
+        message: "At most one option can be recommended",
+        path: ["options"],
+    });
+});
+export const questionnaireInputSchema = z
+    .object({
+    questions: z.array(questionnaireQuestionSchema).min(1).max(3),
+})
+    .superRefine(({ questions }, context) => {
+    const questionIds = new Set();
+    questions.forEach(({ id }, index) => {
+        if (questionIds.has(id)) {
+            context.addIssue({
+                code: "custom",
+                message: "Question IDs must be unique",
+                path: ["questions", index, "id"],
+            });
+        }
+        questionIds.add(id);
+    });
+});
+const questionnaireAnswerSchema = z.discriminatedUnion("source", [
+    z.object({
+        questionId: z.string().trim().min(1),
+        source: z.literal("option"),
+        value: z.string().trim().min(1),
+    }),
+    z.object({
+        questionId: z.string().trim().min(1),
+        source: z.literal("other"),
+        value: z.string().trim().min(1),
+    }),
+    z.object({
+        questionId: z.string().trim().min(1),
+        source: z.literal("skipped"),
+    }),
+]);
+export const questionnaireOutputSchema = z.object({
+    answers: z.array(questionnaireAnswerSchema).min(1).max(3),
+});

package/dist/shared/rdf-namespaces.d.ts

@@ -0,0 +1,11 @@
+export declare const rulesGraphIri = "https://rdfox.com/default-base-iri/rules";
+export declare const ontologyGraphIri: string;
+export declare const writeLifecycle: {
+    predicate: string;
+    readOnly: string;
+    createOnly: string;
+};
+export declare const nonDataGraphIris: string[];
+export declare function mintInstanceIri(classIri: string, localId: string): string;
+export { baseIri, compactUri, decodeIriLocalName, encodeIriLocalName, encodeIriUnsafeChars, expandPrefix, formatEntityName, formatIriForRdfox, getNamespaceValues, isFullIri, isValidFullIri, isIri, isIsoDatetime, infrastructureNamespaces, iriLocalName, iriNamespace, isOwlNothing, owlNothingIri, isPrefixedIri, labeledNamespaces, type LabeledNamespacePrefix, namespaces, type NamespaceMeta, nfo, parseEntityUri, prependMissingSparqlPrefixes, rdfoxDefaultBaseIri, shaclGraphIri, sh, toTurtlePrefixes, validateFullIri, wellKnownPredicates, type IRI, } from "@manta-eu/rdf-lib/namespaces";
+//# sourceMappingURL=rdf-namespaces.d.ts.map

package/dist/shared/rdf-namespaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rdf-namespaces.d.ts","sourceRoot":"","sources":["../../src/shared/rdf-namespaces.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,aAAa,6CAAqC,CAAC;AAGhE,eAAO,MAAM,gBAAgB,QAA+B,CAAC;AAG7D,eAAO,MAAM,cAAc;;;;CAI1B,CAAC;AAEF,eAAO,MAAM,gBAAgB,UAAwD,CAAC;AAEtF,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,OAAO,EACL,OAAO,EACP,UAAU,EACV,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,SAAS,EACT,cAAc,EACd,KAAK,EACL,aAAa,EACb,wBAAwB,EACxB,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,KAAK,sBAAsB,EAC3B,UAAU,EACV,KAAK,aAAa,EAClB,GAAG,EACH,cAAc,EACd,4BAA4B,EAC5B,mBAAmB,EACnB,aAAa,EACb,EAAE,EACF,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,KAAK,GAAG,GACT,MAAM,8BAA8B,CAAC"}

package/dist/shared/rdf-namespaces.js

@@ -0,0 +1,15 @@
+import { encodeIriLocalName as encodeIriLocalNameValue, 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");
+// Field mutability Inferal publishes on its property shapes (DAT-577).
+export const writeLifecycle = {
+    predicate: expandPrefixIri("relay:writeLifecycle"),
+    readOnly: expandPrefixIri("relay:ReadOnly"),
+    createOnly: expandPrefixIri("relay:CreateOnly"),
+};
+export const nonDataGraphIris = [ontologyGraphIri, shaclGraphIriValue, rulesGraphIri];
+export function mintInstanceIri(classIri, localId) {
+    return `${iriNamespaceValue(classIri)}${encodeIriLocalNameValue(`${iriLocalNameValue(classIri)}_${localId}`)}`;
+}
+export { baseIri, compactUri, decodeIriLocalName, encodeIriLocalName, encodeIriUnsafeChars, expandPrefix, formatEntityName, formatIriForRdfox, getNamespaceValues, isFullIri, isValidFullIri, isIri, isIsoDatetime, infrastructureNamespaces, iriLocalName, iriNamespace, isOwlNothing, owlNothingIri, isPrefixedIri, labeledNamespaces, namespaces, nfo, parseEntityUri, prependMissingSparqlPrefixes, rdfoxDefaultBaseIri, shaclGraphIri, sh, toTurtlePrefixes, validateFullIri, wellKnownPredicates, } from "@manta-eu/rdf-lib/namespaces";

package/dist/shared/rule-iri.d.ts

@@ -0,0 +1,4 @@
+export declare const ruleNameMaxLength = 255;
+export declare function sanitizeRuleName(value: string): string;
+export declare function normalizeRuleLocalName(value: string): string | null;
+//# sourceMappingURL=rule-iri.d.ts.map

package/dist/shared/rule-iri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-iri.d.ts","sourceRoot":"","sources":["../../src/shared/rule-iri.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKtD;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAKnE"}

package/dist/shared/rule-iri.js

@@ -0,0 +1,13 @@
+export const ruleNameMaxLength = 255;
+export function sanitizeRuleName(value) {
+    return value
+        .trim()
+        .replace(/[^a-zA-Z0-9_-]+/g, "_")
+        .replace(/^[-_]+|[-_]+$/g, "");
+}
+export function normalizeRuleLocalName(value) {
+    const sanitizedName = sanitizeRuleName(value);
+    if (!sanitizedName)
+        return null;
+    return sanitizedName.startsWith("Rule_") ? sanitizedName : `Rule_${sanitizedName}`;
+}

package/dist/shared/rule-search.d.ts

@@ -0,0 +1,2 @@
+export declare const ruleSearchMaxLength = 200;
+//# sourceMappingURL=rule-search.d.ts.map

package/dist/shared/rule-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-search.d.ts","sourceRoot":"","sources":["../../src/shared/rule-search.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,MAAM,CAAC"}

package/dist/shared/rule-search.js

@@ -0,0 +1 @@
+export const ruleSearchMaxLength = 200;

package/dist/shared/session-types.d.ts

@@ -0,0 +1,14 @@
+export type User = {
+    id: string;
+    email: string;
+    name?: string | null | undefined;
+};
+/** Structurally the same as `@manta-eu/ldo-ui`'s picker row, so either satisfies the other. */
+export type Datastore = {
+    id: string;
+    name: string;
+    depth?: number;
+    selectable?: boolean;
+    badge?: string;
+};
+//# sourceMappingURL=session-types.d.ts.map

package/dist/shared/session-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-types.d.ts","sourceRoot":"","sources":["../../src/shared/session-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CAClC,CAAC;AAEF,+FAA+F;AAC/F,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/dist/shared/session-types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/spa-routes.d.ts

@@ -0,0 +1,3 @@
+export declare const globalSpaRoutes: string[];
+export declare const scopedSpaRoutes: string[];
+//# sourceMappingURL=spa-routes.d.ts.map

package/dist/shared/spa-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spa-routes.d.ts","sourceRoot":"","sources":["../../src/shared/spa-routes.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,UAAwC,CAAC;AAErE,eAAO,MAAM,eAAe,UAAoD,CAAC"}

package/dist/shared/spa-routes.js

@@ -0,0 +1,5 @@
+const errorRoutePath = "/error";
+import { datastoreRoutePaths, globalRoutePaths } from "./datastore-route-table.js";
+// A wildcard instead of scopedSpaRoutes would answer /d/<id>/graphql, and every typo, with index.html.
+export const globalSpaRoutes = [errorRoutePath, ...globalRoutePaths];
+export const scopedSpaRoutes = ["", "/", errorRoutePath, ...datastoreRoutePaths];