@navai/voice-frontend 0.1.0

package/dist/index.js

@@ -0,0 +1,685 @@
+// src/agent.ts
+import { RealtimeAgent, tool } from "@openai/agents/realtime";
+import { z } from "zod";
+
+// src/functions.ts
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function normalizeName(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function stripKnownExtensions(filename) {
+  let output = filename;
+  output = output.replace(/\.(ts|js)$/i, "");
+  output = output.replace(/\.fn$/i, "");
+  return output;
+}
+function getModuleStem(path) {
+  const parts = path.split("/");
+  const last = parts[parts.length - 1] ?? "module";
+  const stem = stripKnownExtensions(last);
+  return stem || "module";
+}
+function isClassConstructor(value) {
+  if (typeof value !== "function") return false;
+  const source = Function.prototype.toString.call(value);
+  return /^\s*class\s/.test(source);
+}
+function isCallable(value) {
+  return typeof value === "function";
+}
+function readArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function buildInvocationArgs(payload, context, targetArity) {
+  const directArgs = readArray(payload.args ?? payload.arguments);
+  const args = directArgs.length > 0 ? [...directArgs] : [];
+  if (args.length === 0 && "value" in payload) {
+    args.push(payload.value);
+  } else if (args.length === 0 && Object.keys(payload).length > 0) {
+    args.push(payload);
+  }
+  if (targetArity > args.length) {
+    args.push(context);
+  }
+  return args;
+}
+function makeFunctionDefinition(name, description, source, callable) {
+  return {
+    name,
+    description,
+    source,
+    run: async (payload, context) => {
+      const args = buildInvocationArgs(payload, context, callable.length);
+      return await callable(...args);
+    }
+  };
+}
+function makeClassMethodDefinition(name, description, source, ClassRef, method) {
+  return {
+    name,
+    description,
+    source,
+    run: async (payload, context) => {
+      const constructorArgs = readArray(payload.constructorArgs);
+      const methodArgsFromPayload = readArray(payload.methodArgs);
+      const args = methodArgsFromPayload.length > 0 ? [...methodArgsFromPayload] : buildInvocationArgs(payload, context, method.length);
+      const instance = new ClassRef(...constructorArgs);
+      const boundMethod = method.bind(instance);
+      if (methodArgsFromPayload.length > 0 && method.length > args.length) {
+        args.push(context);
+      }
+      return await boundMethod(...args);
+    }
+  };
+}
+function uniqueName(baseName, usedNames) {
+  const candidate = normalizeName(baseName) || "fn";
+  if (!usedNames.has(candidate)) {
+    usedNames.add(candidate);
+    return candidate;
+  }
+  let index = 2;
+  while (usedNames.has(`${candidate}_${index}`)) {
+    index += 1;
+  }
+  const finalName = `${candidate}_${index}`;
+  usedNames.add(finalName);
+  return finalName;
+}
+function collectFromClass(path, exportName, ClassRef, usedNames) {
+  const defs = [];
+  const warnings = [];
+  const className = ClassRef.name || getModuleStem(path);
+  const proto = ClassRef.prototype;
+  const methodNames = Object.getOwnPropertyNames(proto).filter((name) => name !== "constructor");
+  if (methodNames.length === 0) {
+    warnings.push(`[navai] Ignored ${path}#${exportName}: class has no callable instance methods.`);
+    return { defs, warnings };
+  }
+  for (const methodName of methodNames) {
+    const descriptor = Object.getOwnPropertyDescriptor(proto, methodName);
+    const method = descriptor?.value;
+    if (!isCallable(method)) {
+      continue;
+    }
+    const rawName = `${className}_${methodName}`;
+    const finalName = uniqueName(rawName, usedNames);
+    if (finalName !== normalizeName(rawName)) {
+      warnings.push(`[navai] Renamed duplicated function "${rawName}" to "${finalName}".`);
+    }
+    defs.push(
+      makeClassMethodDefinition(
+        finalName,
+        `Call class method ${className}.${methodName}().`,
+        `${path}#${exportName}.${methodName}`,
+        ClassRef,
+        method
+      )
+    );
+  }
+  return { defs, warnings };
+}
+function collectFromObject(path, exportName, value, usedNames) {
+  const defs = [];
+  const warnings = [];
+  const callableEntries = Object.entries(value);
+  if (callableEntries.length === 0) {
+    warnings.push(`[navai] Ignored ${path}#${exportName}: exported object has no callable members.`);
+    return { defs, warnings };
+  }
+  const stem = getModuleStem(path);
+  for (const [memberName, member] of callableEntries) {
+    if (!isCallable(member)) {
+      continue;
+    }
+    const rawName = `${exportName === "default" ? stem : exportName}_${memberName}`;
+    const finalName = uniqueName(rawName, usedNames);
+    if (finalName !== normalizeName(rawName)) {
+      warnings.push(`[navai] Renamed duplicated function "${rawName}" to "${finalName}".`);
+    }
+    defs.push(
+      makeFunctionDefinition(
+        finalName,
+        `Call exported object member ${exportName}.${memberName}().`,
+        `${path}#${exportName}.${memberName}`,
+        member
+      )
+    );
+  }
+  if (defs.length === 0) {
+    warnings.push(`[navai] Ignored ${path}#${exportName}: exported object has no callable members.`);
+  }
+  return { defs, warnings };
+}
+function collectFromExportValue(path, exportName, value, usedNames) {
+  if (isClassConstructor(value)) {
+    return collectFromClass(path, exportName, value, usedNames);
+  }
+  if (isCallable(value)) {
+    const fnName = exportName === "default" ? value.name || getModuleStem(path) : exportName;
+    const finalName = uniqueName(fnName, usedNames);
+    const warning = finalName !== normalizeName(fnName) ? [`[navai] Renamed duplicated function "${fnName}" to "${finalName}".`] : [];
+    return {
+      defs: [
+        makeFunctionDefinition(
+          finalName,
+          `Call exported function ${exportName}.`,
+          `${path}#${exportName}`,
+          value
+        )
+      ],
+      warnings: warning
+    };
+  }
+  if (value && typeof value === "object") {
+    return collectFromObject(path, exportName, value, usedNames);
+  }
+  return {
+    defs: [],
+    warnings: []
+  };
+}
+async function loadNavaiFunctions(functionModuleLoaders) {
+  const byName = /* @__PURE__ */ new Map();
+  const ordered = [];
+  const warnings = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  const entries = Object.entries(functionModuleLoaders).filter(([path]) => !path.endsWith(".d.ts")).sort(([a], [b]) => a.localeCompare(b));
+  for (const [path, load] of entries) {
+    try {
+      const imported = await load();
+      const exportEntries = Object.entries(imported);
+      if (exportEntries.length === 0) {
+        warnings.push(`[navai] Ignored ${path}: module has no exports.`);
+        continue;
+      }
+      const defsBeforeModule = ordered.length;
+      for (const [exportName, value] of exportEntries) {
+        const { defs, warnings: exportWarnings } = collectFromExportValue(path, exportName, value, usedNames);
+        warnings.push(...exportWarnings);
+        for (const definition of defs) {
+          byName.set(definition.name, definition);
+          ordered.push(definition);
+        }
+      }
+      if (ordered.length === defsBeforeModule) {
+        warnings.push(`[navai] Ignored ${path}: module has no callable exports.`);
+      }
+    } catch (error) {
+      warnings.push(`[navai] Failed to load ${path}: ${toErrorMessage(error)}`);
+    }
+  }
+  return { byName, ordered, warnings };
+}
+
+// src/routes.ts
+function normalize(value) {
+  return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").trim().toLowerCase();
+}
+function resolveNavaiRoute(input, routes = []) {
+  const normalized = normalize(input);
+  const direct = routes.find((route) => normalize(route.path) === normalized);
+  if (direct) return direct.path;
+  for (const route of routes) {
+    if (normalize(route.name) === normalized) return route.path;
+    if (route.synonyms?.some((synonym) => normalize(synonym) === normalized)) return route.path;
+  }
+  for (const route of routes) {
+    if (normalized.includes(normalize(route.name))) return route.path;
+    if (route.synonyms?.some((synonym) => normalized.includes(normalize(synonym)))) return route.path;
+  }
+  return null;
+}
+function getNavaiRoutePromptLines(routes = []) {
+  return routes.map((route) => {
+    const synonyms = route.synonyms?.length ? `, aliases: ${route.synonyms.join(", ")}` : "";
+    return `- ${route.name} (${route.path})${synonyms}`;
+  });
+}
+
+// src/agent.ts
+function toErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function buildNavaiAgent(options) {
+  const functionsRegistry = await loadNavaiFunctions(options.functionModuleLoaders ?? {});
+  const backendWarnings = [];
+  const backendFunctionsByName = /* @__PURE__ */ new Map();
+  const backendFunctionsOrdered = [];
+  for (const backendFunction of options.backendFunctions ?? []) {
+    const name = backendFunction.name.trim().toLowerCase();
+    if (!name) {
+      continue;
+    }
+    if (functionsRegistry.byName.has(name)) {
+      backendWarnings.push(
+        `[navai] Ignored backend function "${backendFunction.name}": name conflicts with a frontend function.`
+      );
+      continue;
+    }
+    if (backendFunctionsByName.has(name)) {
+      backendWarnings.push(`[navai] Ignored duplicated backend function "${backendFunction.name}".`);
+      continue;
+    }
+    const normalizedDefinition = {
+      ...backendFunction,
+      name
+    };
+    backendFunctionsByName.set(name, normalizedDefinition);
+    backendFunctionsOrdered.push(normalizedDefinition);
+  }
+  const availableFunctionNames = [
+    ...functionsRegistry.ordered.map((item) => item.name),
+    ...backendFunctionsOrdered.map((item) => item.name)
+  ];
+  const navigateTool = tool({
+    name: "navigate_to",
+    description: "Navigate to an allowed route in the current app.",
+    parameters: z.object({
+      target: z.string().min(1).describe("Route name or route path. Example: perfil, ajustes, /profile, /settings")
+    }),
+    execute: async ({ target }) => {
+      const path = resolveNavaiRoute(target, options.routes);
+      if (!path) {
+        return { ok: false, error: "Unknown or disallowed route." };
+      }
+      options.navigate(path);
+      return { ok: true, path };
+    }
+  });
+  const executeFunctionTool = tool({
+    name: "execute_app_function",
+    description: "Execute an allowed internal app function by name.",
+    parameters: z.object({
+      function_name: z.string().min(1).describe("Allowed function name from the list."),
+      payload: z.record(z.string(), z.unknown()).nullable().describe(
+        "Payload object. Use null when no arguments are needed. Use payload.args as array for function args, payload.constructorArgs for class constructors, payload.methodArgs for class methods."
+      )
+    }),
+    execute: async ({ function_name, payload }) => {
+      const requested = function_name.trim().toLowerCase();
+      const frontendDefinition = functionsRegistry.byName.get(requested);
+      if (frontendDefinition) {
+        try {
+          const result = await frontendDefinition.run(payload ?? {}, options);
+          return { ok: true, function_name: frontendDefinition.name, source: frontendDefinition.source, result };
+        } catch (error) {
+          return {
+            ok: false,
+            function_name: frontendDefinition.name,
+            error: "Function execution failed.",
+            details: toErrorMessage2(error)
+          };
+        }
+      }
+      const backendDefinition = backendFunctionsByName.get(requested);
+      if (!backendDefinition) {
+        return {
+          ok: false,
+          error: "Unknown or disallowed function.",
+          available_functions: availableFunctionNames
+        };
+      }
+      if (!options.executeBackendFunction) {
+        return {
+          ok: false,
+          function_name: backendDefinition.name,
+          error: "Backend function execution is not configured."
+        };
+      }
+      try {
+        const result = await options.executeBackendFunction({
+          functionName: backendDefinition.name,
+          payload: payload ?? null
+        });
+        return {
+          ok: true,
+          function_name: backendDefinition.name,
+          source: backendDefinition.source ?? "backend",
+          result
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          function_name: backendDefinition.name,
+          error: "Function execution failed.",
+          details: toErrorMessage2(error)
+        };
+      }
+    }
+  });
+  const routeLines = getNavaiRoutePromptLines(options.routes);
+  const functionLines = functionsRegistry.ordered.length + backendFunctionsOrdered.length > 0 ? [
+    ...functionsRegistry.ordered.map((item) => `- ${item.name}: ${item.description}`),
+    ...backendFunctionsOrdered.map(
+      (item) => `- ${item.name}: ${item.description ?? "Execute backend function."}`
+    )
+  ] : ["- none"];
+  const instructions = [
+    options.baseInstructions ?? "You are a voice assistant embedded in a web app.",
+    "Allowed routes:",
+    ...routeLines,
+    "Allowed app functions:",
+    ...functionLines,
+    "Rules:",
+    "- If user asks to go/open a section, always call navigate_to.",
+    "- If user asks to run an internal action, always call execute_app_function.",
+    "- Always include payload in execute_app_function. Use null when no arguments are needed.",
+    "- For execute_app_function, pass arguments using payload.args (array).",
+    "- For class methods, pass payload.constructorArgs and payload.methodArgs.",
+    "- Never invent routes or function names that are not listed.",
+    "- If destination/action is unclear, ask a brief clarifying question."
+  ].join("\n");
+  const agent = new RealtimeAgent({
+    name: options.agentName ?? "Navai Voice Agent",
+    instructions,
+    tools: [navigateTool, executeFunctionTool]
+  });
+  return { agent, warnings: [...functionsRegistry.warnings, ...backendWarnings] };
+}
+
+// src/backend.ts
+var DEFAULT_API_BASE_URL = "http://localhost:3000";
+var DEFAULT_CLIENT_SECRET_PATH = "/navai/realtime/client-secret";
+var DEFAULT_FUNCTIONS_LIST_PATH = "/navai/functions";
+var DEFAULT_FUNCTIONS_EXECUTE_PATH = "/navai/functions/execute";
+function readOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function joinUrl(baseUrl, path) {
+  const cleanBase = baseUrl.replace(/\/+$/, "");
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  return `${cleanBase}${cleanPath}`;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object");
+}
+async function readTextSafe(response) {
+  try {
+    return await response.text();
+  } catch {
+    return `HTTP ${response.status}`;
+  }
+}
+async function readJsonSafe(response) {
+  try {
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+function createNavaiBackendClient(options = {}) {
+  const apiBaseUrl = readOptional(options.apiBaseUrl) ?? readOptional(options.env?.NAVAI_API_URL) ?? DEFAULT_API_BASE_URL;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const clientSecretUrl = joinUrl(apiBaseUrl, options.clientSecretPath ?? DEFAULT_CLIENT_SECRET_PATH);
+  const functionsListUrl = joinUrl(apiBaseUrl, options.functionsListPath ?? DEFAULT_FUNCTIONS_LIST_PATH);
+  const functionsExecuteUrl = joinUrl(apiBaseUrl, options.functionsExecutePath ?? DEFAULT_FUNCTIONS_EXECUTE_PATH);
+  async function createClientSecret(input = {}) {
+    const response = await fetchImpl(clientSecretUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input)
+    });
+    if (!response.ok) {
+      throw new Error(await readTextSafe(response));
+    }
+    const payload = await readJsonSafe(response);
+    if (!isRecord(payload) || typeof payload.value !== "string") {
+      throw new Error("Invalid client-secret response.");
+    }
+    return {
+      value: payload.value,
+      expires_at: typeof payload.expires_at === "number" ? payload.expires_at : void 0
+    };
+  }
+  async function listFunctions() {
+    try {
+      const response = await fetchImpl(functionsListUrl);
+      if (!response.ok) {
+        return {
+          functions: [],
+          warnings: [`[navai] Failed to load backend functions (${response.status}).`]
+        };
+      }
+      const payload = await readJsonSafe(response);
+      if (!isRecord(payload)) {
+        return {
+          functions: [],
+          warnings: ["[navai] Failed to parse backend functions response."]
+        };
+      }
+      const rawItems = Array.isArray(payload.items) ? payload.items : [];
+      const rawWarnings = Array.isArray(payload.warnings) ? payload.warnings : [];
+      const functions = rawItems.filter((item) => isRecord(item)).map((item) => ({
+        name: typeof item.name === "string" ? item.name : "",
+        description: typeof item.description === "string" ? item.description : void 0,
+        source: typeof item.source === "string" ? item.source : void 0
+      })).filter((item) => item.name.trim().length > 0);
+      const warnings = rawWarnings.filter((item) => typeof item === "string");
+      return { functions, warnings };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        functions: [],
+        warnings: [`[navai] Failed to load backend functions: ${message}`]
+      };
+    }
+  }
+  const executeFunction = async (input) => {
+    const response = await fetchImpl(functionsExecuteUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        function_name: input.functionName,
+        payload: input.payload
+      })
+    });
+    if (!response.ok) {
+      throw new Error(await readTextSafe(response));
+    }
+    const payload = await readJsonSafe(response);
+    if (!isRecord(payload)) {
+      throw new Error("Invalid backend function response.");
+    }
+    if (payload.ok !== true) {
+      const details = typeof payload.details === "string" ? payload.details : typeof payload.error === "string" ? payload.error : "Backend function failed.";
+      throw new Error(details);
+    }
+    return payload.result;
+  };
+  return {
+    createClientSecret,
+    listFunctions,
+    executeFunction
+  };
+}
+
+// src/runtime.ts
+var ROUTES_ENV_KEYS = ["NAVAI_ROUTES_FILE"];
+var FUNCTIONS_ENV_KEYS = ["NAVAI_FUNCTIONS_FOLDERS"];
+var MODEL_ENV_KEYS = ["NAVAI_REALTIME_MODEL"];
+async function resolveNavaiFrontendRuntimeConfig(options) {
+  const warnings = [];
+  const indexedLoaders = toIndexedLoaders(options.moduleLoaders);
+  const loaderByPath = new Map(indexedLoaders.map((entry) => [entry.normalizedPath, entry]));
+  const defaultRoutesFile = options.defaultRoutesFile ?? "src/ai/routes.ts";
+  const defaultFunctionsFolder = options.defaultFunctionsFolder ?? "src/ai/functions-modules";
+  const routesFile = readOptional2(options.routesFile) ?? readFirstOptionalEnv(options.env, ROUTES_ENV_KEYS) ?? defaultRoutesFile;
+  const functionsFolders = readOptional2(options.functionsFolders) ?? readFirstOptionalEnv(options.env, FUNCTIONS_ENV_KEYS) ?? defaultFunctionsFolder;
+  const modelOverride = readOptional2(options.modelOverride) ?? readFirstOptionalEnv(options.env, MODEL_ENV_KEYS);
+  const routes = await resolveRoutes({
+    routesFile,
+    defaultRoutesFile,
+    defaultRoutes: options.defaultRoutes,
+    loaderByPath,
+    warnings
+  });
+  const functionModuleLoaders = resolveFunctionModuleLoaders({
+    indexedLoaders,
+    functionsFolders,
+    defaultFunctionsFolder,
+    warnings
+  });
+  return {
+    routes,
+    functionModuleLoaders,
+    modelOverride,
+    warnings
+  };
+}
+async function resolveRoutes(input) {
+  const candidates = buildModuleCandidates(input.routesFile);
+  if (candidates.includes(input.defaultRoutesFile)) {
+    return input.defaultRoutes;
+  }
+  const matchedLoader = candidates.map((candidate) => input.loaderByPath.get(candidate)).find(Boolean);
+  if (!matchedLoader) {
+    input.warnings.push(
+      `[navai] Route module "${input.routesFile}" was not found. Falling back to "${input.defaultRoutesFile}".`
+    );
+    return input.defaultRoutes;
+  }
+  try {
+    const imported = await matchedLoader.load();
+    const loadedRoutes = readRouteItems(imported);
+    if (!loadedRoutes) {
+      input.warnings.push(
+        `[navai] Route module "${input.routesFile}" must export NavaiRoute[] (NAVAI_ROUTE_ITEMS or default). Falling back to "${input.defaultRoutesFile}".`
+      );
+      return input.defaultRoutes;
+    }
+    return loadedRoutes;
+  } catch (error) {
+    input.warnings.push(
+      `[navai] Failed to load route module "${input.routesFile}": ${toErrorMessage3(error)}. Falling back to "${input.defaultRoutesFile}".`
+    );
+    return input.defaultRoutes;
+  }
+}
+function resolveFunctionModuleLoaders(input) {
+  const configuredTokens = input.functionsFolders.split(",").map((value) => value.trim()).filter(Boolean);
+  const tokens = configuredTokens.length > 0 ? configuredTokens : [input.defaultFunctionsFolder];
+  const matchers = tokens.map((token) => createPathMatcher(token));
+  const matchedEntries = input.indexedLoaders.filter(
+    (entry) => !entry.normalizedPath.endsWith(".d.ts") && !entry.normalizedPath.startsWith("src/node_modules/") && matchers.some((matcher) => matcher(entry.normalizedPath))
+  );
+  if (matchedEntries.length > 0) {
+    return Object.fromEntries(matchedEntries.map((entry) => [entry.rawPath, entry.load]));
+  }
+  if (configuredTokens.length > 0) {
+    input.warnings.push(
+      `[navai] NAVAI_FUNCTIONS_FOLDERS did not match any module: "${input.functionsFolders}". Falling back to "${input.defaultFunctionsFolder}".`
+    );
+  }
+  const fallbackMatcher = createPathMatcher(input.defaultFunctionsFolder);
+  const fallbackEntries = input.indexedLoaders.filter(
+    (entry) => !entry.normalizedPath.endsWith(".d.ts") && !entry.normalizedPath.startsWith("src/node_modules/") && fallbackMatcher(entry.normalizedPath)
+  );
+  return Object.fromEntries(fallbackEntries.map((entry) => [entry.rawPath, entry.load]));
+}
+function toIndexedLoaders(loaders) {
+  return Object.entries(loaders).map(([rawPath, load]) => ({
+    rawPath,
+    normalizedPath: normalizePath(rawPath),
+    load
+  }));
+}
+function readRouteItems(moduleShape) {
+  const candidate = moduleShape.NAVAI_ROUTE_ITEMS ?? moduleShape.NAVAI_ROUTES ?? moduleShape.APP_ROUTES ?? moduleShape.routes ?? moduleShape.default;
+  if (!Array.isArray(candidate)) {
+    return null;
+  }
+  if (!candidate.every(isNavaiRoute)) {
+    return null;
+  }
+  return candidate;
+}
+function isNavaiRoute(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const route = value;
+  if (typeof route.name !== "string" || typeof route.path !== "string" || typeof route.description !== "string") {
+    return false;
+  }
+  if (!Array.isArray(route.synonyms) && route.synonyms !== void 0) {
+    return false;
+  }
+  return route.synonyms ? route.synonyms.every((item) => typeof item === "string") : true;
+}
+function buildModuleCandidates(inputPath) {
+  const normalized = normalizePath(inputPath);
+  const srcPrefixed = normalized.startsWith("src/") ? normalized : `src/${normalized}`;
+  const hasExtension = /\.[cm]?[jt]s$/.test(srcPrefixed);
+  if (hasExtension) {
+    return [srcPrefixed];
+  }
+  return [srcPrefixed, `${srcPrefixed}.ts`, `${srcPrefixed}.js`, `${srcPrefixed}/index.ts`, `${srcPrefixed}/index.js`];
+}
+function createPathMatcher(input) {
+  const raw = normalizePath(input);
+  if (!raw) {
+    return () => false;
+  }
+  const normalized = raw.startsWith("src/") ? raw : `src/${raw}`;
+  if (normalized.endsWith("/...")) {
+    const base2 = normalized.slice(0, -4).replace(/\/+$/, "");
+    return (path) => path.startsWith(`${base2}/`);
+  }
+  if (normalized.includes("*")) {
+    const regexp = globToRegExp(normalized);
+    return (path) => regexp.test(path);
+  }
+  if (/\.[cm]?[jt]s$/.test(normalized)) {
+    return (path) => path === normalized;
+  }
+  const base = normalized.replace(/\/+$/, "");
+  return (path) => path === base || path.startsWith(`${base}/`);
+}
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const wildcardSafe = escaped.replace(/\*\*/g, "___DOUBLE_STAR___");
+  const single = wildcardSafe.replace(/\*/g, "[^/]*");
+  const output = single.replace(/___DOUBLE_STAR___/g, ".*");
+  return new RegExp(`^${output}$`);
+}
+function normalizePath(input) {
+  return input.trim().replace(/\\/g, "/").replace(/^\/+/, "").replace(/^(\.\/)+/, "").replace(/^(\.\.\/)+/, "");
+}
+function readFirstOptionalEnv(env, keys) {
+  if (!env) {
+    return void 0;
+  }
+  for (const key of keys) {
+    const value = readOptionalEnvValue(env, key);
+    if (value) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function readOptionalEnvValue(env, key) {
+  const value = env[key];
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  return readOptional2(value);
+}
+function readOptional2(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function toErrorMessage3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  buildNavaiAgent,
+  createNavaiBackendClient,
+  getNavaiRoutePromptLines,
+  loadNavaiFunctions,
+  resolveNavaiFrontendRuntimeConfig,
+  resolveNavaiRoute
+};