@nirmos/sdk 0.2.0 → 0.3.2

package/src/prompts/variables.ts

@@ -0,0 +1,156 @@
+/** Shared placeholder semantics for managed prompts, the dashboard and execution. */
+export const PROMPT_VARIABLE_PATTERN =
+  /\{\{\s*([a-zA-Z][a-zA-Z0-9_.-]*)\s*\}\}/g;
+export function extractPromptVariableNames(
+  ...values: Array<string | null | undefined>
+): string[] {
+  return [
+    ...new Set(
+      values.flatMap((value) =>
+        [...(value ?? "").matchAll(PROMPT_VARIABLE_PATTERN)].map(
+          (match) => match[1]!,
+        ),
+      ),
+    ),
+  ];
+}
+export function promptVariableValue(
+  values: Record<string, unknown>,
+  name: string,
+): unknown {
+  if (Object.hasOwn(values, name)) return values[name];
+  let current: unknown = values;
+  for (const key of name.split(".")) {
+    if (
+      ["__proto__", "prototype", "constructor"].includes(key) ||
+      !current ||
+      typeof current !== "object" ||
+      !Object.hasOwn(current, key)
+    )
+      return undefined;
+    current = (current as Record<string, unknown>)[key];
+  }
+  return current;
+}
+export function interpolatePromptVariables(
+  text: string,
+  values: Record<string, unknown>,
+): string {
+  return text.replace(PROMPT_VARIABLE_PATTERN, (token, name: string) => {
+    const value = promptVariableValue(values, name);
+    return value === undefined
+      ? token
+      : typeof value === "string"
+        ? value
+        : JSON.stringify(value);
+  });
+}
+export function validatePromptTemplate(text: string): string[] {
+  const remaining = text.replace(PROMPT_VARIABLE_PATTERN, "");
+  return /\{\{|\{%/.test(remaining)
+    ? [
+        "Unsupported variable syntax. Use {{name}}, {{ spaced }}, or {{user.name}}. Expressions, filters and template blocks cannot run as managed prompt variables.",
+      ]
+    : [];
+}
+export type VariableDefinition = {
+  name: string;
+  type: string;
+  required?: boolean;
+  default?: unknown;
+  enum?: readonly string[];
+  values?: readonly string[];
+  min?: number;
+  max?: number;
+  minLength?: number;
+  maxLength?: number;
+  min_length?: number;
+  max_length?: number;
+  itemType?: string;
+  item_type?: string;
+};
+export function validatePromptVariableValues(
+  definitions: readonly VariableDefinition[],
+  values: Record<string, unknown>,
+): Record<string, string> {
+  const errors: Record<string, string> = {};
+  for (const definition of definitions) {
+    const supplied = promptVariableValue(values, definition.name);
+    const value = supplied === undefined ? definition.default : supplied;
+    let error = "";
+    if (value === undefined || value === "") {
+      if (definition.required) error = "A value is required.";
+    } else {
+      const type = definition.type;
+      if (
+        type === "number" &&
+        (typeof value !== "number" || !Number.isFinite(value))
+      )
+        error = "Enter a valid number.";
+      if (type === "boolean" && typeof value !== "boolean")
+        error = "Choose true or false.";
+      if (type === "string" && typeof value !== "string") error = "Enter text.";
+      if (
+        type === "enum" &&
+        !(definition.enum ?? definition.values)?.includes(String(value))
+      )
+        error = "Choose one of the allowed values.";
+      if (type === "array" && !Array.isArray(value))
+        error = "Enter a valid array.";
+      if (
+        typeof value === "number" &&
+        ((definition.min !== undefined && value < definition.min) ||
+          (definition.max !== undefined && value > definition.max))
+      )
+        error = `Enter a number between ${definition.min ?? "−∞"} and ${definition.max ?? "∞"}.`;
+      const minLength = definition.minLength ?? definition.min_length;
+      const maxLength = definition.maxLength ?? definition.max_length;
+      if (
+        typeof value === "string" &&
+        ((minLength !== undefined && value.length < minLength) ||
+          (maxLength !== undefined && value.length > maxLength))
+      )
+        error = `Use ${minLength ?? 0} to ${maxLength ?? "any number of"} characters.`;
+      const itemType = definition.itemType ?? definition.item_type;
+      if (
+        Array.isArray(value) &&
+        itemType &&
+        value.some((item) =>
+          itemType === "array"
+            ? !Array.isArray(item)
+            : itemType !== "enum" && typeof item !== itemType,
+        )
+      )
+        error = `Every item must be ${itemType}.`;
+    }
+    if (error) errors[definition.name] = error;
+  }
+  return errors;
+}
+export function validatePromptSettings(settings: {
+  temperature: unknown;
+  topP: unknown;
+  maxTokens: unknown;
+}): Record<string, string> {
+  const errors: Record<string, string> = {};
+  for (const [field, label, min, max] of [
+    ["temperature", "Temperature", 0, 2],
+    ["topP", "Top P", 0, 1],
+    ["maxTokens", "Max tokens", 1, 200000],
+  ] as const) {
+    const raw = settings[field];
+    const value = Number(raw);
+    if (
+      raw === "" ||
+      raw === null ||
+      raw === undefined ||
+      !Number.isFinite(value) ||
+      value < min ||
+      value > max ||
+      (field === "maxTokens" && !Number.isInteger(value))
+    )
+      errors[field] =
+        `${label} must be ${field === "maxTokens" ? "a whole number" : "a number"} between ${min} and ${max}.`;
+  }
+  return errors;
+}