trellis 1.0.6 → 1.0.8

package/dist/ai/index.js

@@ -0,0 +1,688 @@
+// src/ai/orchestrator.ts
+import { openai } from "@ai-sdk/openai";
+import { generateText, streamText, generateObject } from "ai";
+import { z } from "zod";
+import { randomUUID } from "crypto";
+var IntentSchema = z.enum([
+  "conversation",
+  "question",
+  "task",
+  "query",
+  "command",
+  "help",
+  "error"
+]);
+var ActionSchema = z.enum([
+  "streamResponse",
+  "generateResponse",
+  "executeTask",
+  "runQuery",
+  "showHelp",
+  "none"
+]);
+var TaskTypeSchema = z.enum([
+  "creative_writing",
+  "analysis",
+  "calculation",
+  "code_generation",
+  "data_processing",
+  "general"
+]);
+var ComplexitySchema = z.enum(["simple", "moderate", "complex"]);
+var SentimentSchema = z.enum(["positive", "negative", "neutral"]).optional();
+var ToneSchema = z.enum(["formal", "casual", "urgent", "friendly", "technical"]).optional();
+var MetaSchema = z.object({
+  intent: IntentSchema,
+  reason: z.string(),
+  action: ActionSchema,
+  confidence: z.number().min(0).max(1),
+  sentiment: SentimentSchema,
+  tone: ToneSchema,
+  taskType: TaskTypeSchema.optional(),
+  complexity: ComplexitySchema.optional(),
+  estimatedTime: z.number().optional()
+});
+var PlanSchema = z.object({
+  rationale: z.string(),
+  steps: z.array(z.string()).min(1),
+  assumptions: z.array(z.string()).optional(),
+  risks: z.array(z.string()).optional(),
+  revisedPrompt: z.string().optional(),
+  toolHints: z.array(z.string()).optional()
+});
+var PlanVoteSchema = z.object({
+  winningIndex: z.number().int().min(0),
+  reason: z.string()
+});
+var OrchestratorOptionsSchema = z.object({
+  stream: z.boolean().optional(),
+  maxRetries: z.number().min(0).max(5).default(2),
+  timeoutMs: z.number().positive().default(30000),
+  includeAnalysis: z.boolean().default(true),
+  fallbackToConversation: z.boolean().default(true),
+  useToT: z.boolean().default(false),
+  plannerModel: z.string().default("gpt-4o-mini"),
+  numThoughts: z.number().int().min(2).max(8).default(3)
+}).passthrough();
+var OrchestratorOk = z.object({
+  status: z.literal("ok"),
+  meta: MetaSchema,
+  payload: z.object({
+    requestId: z.string().uuid(),
+    prompt: z.string(),
+    options: z.record(z.string(), z.unknown()),
+    response: z.any(),
+    processingTimeMs: z.number(),
+    planning: z.object({
+      winningIndex: z.number(),
+      reason: z.string(),
+      plan: PlanSchema,
+      allPlansCount: z.number()
+    }).optional()
+  })
+});
+var OrchestratorErr = z.object({
+  status: z.literal("error"),
+  meta: MetaSchema,
+  payload: z.object({
+    requestId: z.string().uuid(),
+    prompt: z.string(),
+    options: z.record(z.string(), z.unknown()),
+    error: z.string(),
+    processingTimeMs: z.number(),
+    planning: z.object({
+      winningIndex: z.number(),
+      reason: z.string(),
+      plan: PlanSchema,
+      allPlansCount: z.number()
+    }).optional()
+  })
+});
+var OrchestratorResultSchema = z.union([OrchestratorOk, OrchestratorErr]);
+var DEFAULT_MODEL = openai("gpt-4o-mini");
+var CLASSIFICATION_PROMPT = `You are an intent classifier for a conversational AI orchestrator.
+Analyze the user prompt and return ONLY a JSON object with these fields:
+
+- intent: one of ${IntentSchema.options.join(", ")}
+- reason: brief explanation (max 50 chars)
+- action: one of ${ActionSchema.options.join(", ")}
+- confidence: number 0-1
+- sentiment: optional, one of positive/negative/neutral
+- tone: optional, one of formal/casual/urgent/friendly/technical
+- taskType: optional, one of ${TaskTypeSchema.options.join(", ")} (only for task intent)
+- complexity: optional, one of ${ComplexitySchema.options.join(", ")} (only for task intent)
+- estimatedTime: optional, rough time estimate in seconds (only for task intent)
+
+Guidelines:
+- "conversation": general chat, greetings, casual talk → streamResponse
+- "question": seeking information → streamResponse
+- "task": action requests → executeTask (include taskType, complexity, estimatedTime)
+- "query": data/search requests → runQuery
+- "command": system commands → executeTask
+- "help": assistance requests → showHelp
+
+Task type guidelines:
+- "creative_writing": stories, poems, creative content
+- "analysis": data analysis, research, evaluation
+- "calculation": math, computations, formulas
+- "code_generation": programming, scripts, technical solutions
+- "data_processing": data manipulation, transformation
+- "general": other tasks
+
+User prompt: """{{PROMPT}}"""
+
+Respond with valid JSON only:`;
+
+class OrchestratorError extends Error {
+  code;
+  recoverable;
+  constructor(message, code, recoverable = true) {
+    super(message);
+    this.code = code;
+    this.recoverable = recoverable;
+    this.name = "OrchestratorError";
+  }
+}
+var withTimeout = async (promise, timeoutMs) => {
+  const timeout = new Promise((_, reject) => {
+    setTimeout(() => reject(new OrchestratorError(`Operation timed out after ${timeoutMs}ms`, "TIMEOUT", true)), timeoutMs);
+  });
+  return Promise.race([promise, timeout]);
+};
+var parseJsonSafely = (text) => {
+  const cleaned = text.replace(/^```json\s*/, "").replace(/\s*```$/, "").replace(/^```\s*/, "").trim();
+  return JSON.parse(cleaned);
+};
+var word = (w) => new RegExp(`\\b${w}\\b`, "i");
+var quickClassify = (prompt) => {
+  const p = prompt.trim();
+  if (word("help").test(p)) {
+    return {
+      intent: "help",
+      reason: "help keyword",
+      action: "showHelp",
+      confidence: 0.9
+    };
+  }
+  if (/[?]\s*$/.test(p) || /^(what|how|why|when|where)\b/i.test(p)) {
+    return {
+      intent: "question",
+      reason: "question pattern",
+      action: "streamResponse",
+      confidence: 0.8
+    };
+  }
+  if (word("write").test(p) || word("generate").test(p) || word("create").test(p)) {
+    const isCode = /(code|function|script|program)\b/i.test(p);
+    const isStory = /\b(story|poem|narrative|lyrics?)\b/i.test(p);
+    return {
+      intent: "task",
+      reason: "creation keyword",
+      action: "executeTask",
+      confidence: 0.85,
+      taskType: isCode ? "code_generation" : isStory ? "creative_writing" : "general",
+      complexity: /\b(short|simple)\b/i.test(p) ? "simple" : "moderate",
+      estimatedTime: isCode ? 30 : isStory ? 15 : 20
+    };
+  }
+  return null;
+};
+async function proposePlan({
+  plannerModel,
+  prompt
+}) {
+  try {
+    const { object } = await generateObject({
+      model: openai(plannerModel),
+      temperature: 0.7,
+      maxRetries: 1,
+      prompt: [
+        "You are a planning assistant. Produce a concise plan to solve the user's request.",
+        "Prefer short, actionable steps. Include a revisedPrompt only if it materially improves the request.",
+        "Return a JSON object with: rationale (string), steps (array of strings), assumptions (optional array), risks (optional array), revisedPrompt (optional string).",
+        "",
+        `User prompt:
+${prompt}`
+      ].join(`
+`),
+      schema: PlanSchema
+    });
+    return object;
+  } catch (error) {
+    console.warn("[planner] Plan generation failed:", error instanceof Error ? error.message : String(error));
+    return {
+      rationale: "Fallback plan due to generation error",
+      steps: ["Analyze the request", "Provide a comprehensive response"],
+      assumptions: [],
+      risks: ["Planning failed, using fallback approach"]
+    };
+  }
+}
+async function runToT({
+  plannerModel,
+  prompt,
+  numThoughts
+}) {
+  try {
+    const candidates = await Promise.all(Array.from({ length: numThoughts }, () => proposePlan({ plannerModel, prompt })));
+    const indexed = candidates.map((p, i) => `#${i}
+Rationale: ${p.rationale}
+Steps:
+- ${p.steps.join(`
+- `)}
+`).join(`
+`);
+    const { object: vote } = await generateObject({
+      model: openai(plannerModel),
+      temperature: 0.2,
+      prompt: [
+        "You are a strict judge. Choose the single best plan index for correctness, clarity, and feasibility.",
+        "Return only JSON with the winningIndex (number) and reason (string).",
+        indexed
+      ].join(`
+
+`),
+      schema: PlanVoteSchema
+    });
+    const winningIndex = Math.max(0, Math.min(candidates.length - 1, vote.winningIndex));
+    const winningPlan = candidates[winningIndex];
+    if (!winningPlan) {
+      throw new Error("No winning plan found");
+    }
+    return {
+      plan: winningPlan,
+      allPlans: candidates,
+      winningIndex,
+      reason: vote.reason
+    };
+  } catch (error) {
+    console.warn("[planner] ToT evaluation failed:", error instanceof Error ? error.message : String(error));
+    const fallbackPlan = await proposePlan({ plannerModel, prompt });
+    return {
+      plan: fallbackPlan,
+      allPlans: [fallbackPlan],
+      winningIndex: 0,
+      reason: "Fallback selection due to evaluation error"
+    };
+  }
+}
+var generateResponse = async (prompt, options = {}) => {
+  const { stream = false, timeoutMs = 30000 } = options;
+  if (stream) {
+    const result = await streamText({ model: DEFAULT_MODEL, prompt });
+    return result.textStream;
+  } else {
+    const { text } = await withTimeout(generateText({ model: DEFAULT_MODEL, prompt }), timeoutMs);
+    return text;
+  }
+};
+var classifyIntentLLM = async (prompt, timeoutMs) => {
+  const classificationPrompt = CLASSIFICATION_PROMPT.replace("{{PROMPT}}", prompt);
+  const { text } = await withTimeout(generateText({
+    model: DEFAULT_MODEL,
+    maxRetries: 1,
+    prompt: classificationPrompt
+  }), timeoutMs);
+  const parsed = parseJsonSafely(text);
+  return MetaSchema.parse(parsed);
+};
+var generateFallbackMeta = (prompt, error) => {
+  const lowerPrompt = prompt.toLowerCase().trim();
+  if (lowerPrompt.includes("?") || lowerPrompt.startsWith("what") || lowerPrompt.startsWith("how")) {
+    return {
+      intent: "question",
+      reason: error ? `Fallback: question pattern (${error})` : "Fallback: question pattern detected",
+      action: "streamResponse",
+      confidence: 0.6
+    };
+  }
+  if (lowerPrompt.startsWith("help") || lowerPrompt.includes("help")) {
+    return {
+      intent: "help",
+      reason: error ? `Fallback: help request (${error})` : "Fallback: help pattern detected",
+      action: "showHelp",
+      confidence: 0.7
+    };
+  }
+  return {
+    intent: "conversation",
+    reason: error ? `Fallback: default conversation (${error})` : "Fallback: default conversation",
+    action: "streamResponse",
+    confidence: error ? 0.3 : 0.5
+  };
+};
+var taskHandlers = {
+  code_generation: async ({ prompt, options }) => ({
+    kind: "ok",
+    response: await generateResponse(prompt, { timeoutMs: options.timeoutMs })
+  }),
+  creative_writing: async ({ prompt, meta, options }) => ({
+    kind: "ok",
+    response: await generateResponse(prompt, {
+      stream: meta.complexity === "complex" || /long|novella/i.test(prompt),
+      timeoutMs: options.timeoutMs
+    })
+  }),
+  analysis: async ({ prompt, options }) => ({
+    kind: "ok",
+    response: await generateResponse(prompt, { timeoutMs: options.timeoutMs })
+  }),
+  calculation: async ({ prompt, options }) => ({
+    kind: "ok",
+    response: await generateResponse(prompt, { timeoutMs: options.timeoutMs })
+  }),
+  general: async ({ prompt, options }) => ({
+    kind: "ok",
+    response: await generateResponse(prompt, { timeoutMs: options.timeoutMs })
+  })
+};
+async function routeTask(ctx) {
+  const { meta } = ctx;
+  const handler = meta.taskType && taskHandlers[meta.taskType] || taskHandlers.general;
+  if (!handler)
+    return { kind: "err", error: "No task handler." };
+  return handler(ctx);
+}
+var handlers = {
+  streamResponse: async ({ prompt, options }) => ({
+    kind: "ok",
+    response: await generateResponse(prompt, {
+      stream: true,
+      timeoutMs: options.timeoutMs
+    })
+  }),
+  generateResponse: async ({ prompt, options }) => ({
+    kind: "ok",
+    response: await generateResponse(prompt, {
+      stream: false,
+      timeoutMs: options.timeoutMs
+    })
+  }),
+  showHelp: async () => ({
+    kind: "ok",
+    response: "I can chat, answer questions, run tasks, or queries. What do you need?"
+  }),
+  runQuery: async () => ({
+    kind: "ok",
+    response: "[runQuery] Not implemented yet."
+  }),
+  none: async () => ({
+    kind: "ok",
+    response: "No action required."
+  }),
+  executeTask: routeTask
+};
+var orchestrate = async (prompt, rawOptions = {}) => {
+  const t0 = Date.now();
+  const requestId = randomUUID();
+  const options = OrchestratorOptionsSchema.parse(rawOptions);
+  if (!prompt?.trim())
+    throw new OrchestratorError("Prompt cannot be empty", "EMPTY_PROMPT", false);
+  let meta;
+  const tClassify0 = Date.now();
+  try {
+    meta = options.includeAnalysis ? quickClassify(prompt) ?? await classifyIntentLLM(prompt, options.timeoutMs) : generateFallbackMeta(prompt);
+  } catch (e) {
+    meta = options.fallbackToConversation ? generateFallbackMeta(prompt, e instanceof Error ? e.message : String(e)) : (() => {
+      throw e;
+    })();
+  }
+  const classifyMs = Date.now() - tClassify0;
+  let effectivePrompt = prompt;
+  let planningInfo;
+  const shouldPlan = options.useToT && (meta.intent === "task" || meta.intent === "question" && (meta.complexity === "complex" || /plan|design|evaluate/i.test(prompt)));
+  if (shouldPlan) {
+    try {
+      const { plan, allPlans, winningIndex, reason } = await runToT({
+        plannerModel: options.plannerModel,
+        prompt,
+        numThoughts: options.numThoughts
+      });
+      if (plan.revisedPrompt && plan.revisedPrompt.trim().length > 0) {
+        effectivePrompt = plan.revisedPrompt;
+      }
+      planningInfo = {
+        winningIndex,
+        reason,
+        plan,
+        allPlansCount: allPlans.length
+      };
+    } catch (e) {
+      console.warn("[planner] ToT failed:", e instanceof Error ? e.message : String(e));
+    }
+  }
+  const tExec0 = Date.now();
+  let result;
+  try {
+    const handler = handlers[meta.action] ?? handlers.generateResponse;
+    result = await handler({ prompt: effectivePrompt, meta, options });
+  } catch (e) {
+    result = {
+      kind: "err",
+      error: `Action failed: ${e instanceof Error ? e.message : String(e)}`
+    };
+  }
+  const execMs = Date.now() - tExec0;
+  const processingTimeMs = Date.now() - t0;
+  console.debug(JSON.stringify({
+    requestId,
+    classifyMs,
+    execMs,
+    processingTimeMs,
+    action: meta.action,
+    taskType: meta.taskType
+  }));
+  if (result.kind === "ok") {
+    return {
+      status: "ok",
+      meta,
+      payload: {
+        requestId,
+        prompt,
+        options: rawOptions,
+        response: result.response,
+        processingTimeMs,
+        planning: planningInfo
+      }
+    };
+  } else {
+    return {
+      status: "error",
+      meta,
+      payload: {
+        requestId,
+        prompt,
+        options: rawOptions,
+        error: result.error,
+        processingTimeMs,
+        planning: planningInfo
+      }
+    };
+  }
+};
+var quickOrchestrate = async (prompt, stream = false) => {
+  const result = await orchestrate(prompt, { stream, includeAnalysis: false });
+  if (result.status === "error") {
+    throw new Error(result.payload.error);
+  }
+  return typeof result.payload.response === "string" ? result.payload.response : "No response generated";
+};
+var analyzeIntent = async (prompt) => {
+  const result = await orchestrate(prompt, { includeAnalysis: true });
+  return result.meta;
+};
+var processQuery = async (query, context) => {
+  try {
+    const processedQuery = handleCommonPatterns(query);
+    const entityType = identifyEntityType(processedQuery);
+    const attributes = Array.isArray(context.catalog) ? context.catalog.map((a) => a.attribute).filter(Boolean) : [];
+    const aliasPairs = [];
+    const findAttr = (needle) => attributes.find((a) => needle.test(a));
+    const questionAttr = findAttr(/question$/i);
+    const responseAttr = findAttr(/response$/i);
+    const cotAttr = findAttr(/(complex[_\-.]?cot|chain[_\-.]?of[_\-.]?thought)/i);
+    if (questionAttr)
+      aliasPairs.push({ alias: "question", attr: questionAttr });
+    if (responseAttr)
+      aliasPairs.push({ alias: "response", attr: responseAttr });
+    if (cotAttr)
+      aliasPairs.push({ alias: "reasoning", attr: cotAttr });
+    const aliasInfo = aliasPairs.map(({ alias, attr }) => `- ${alias} ⇒ ${attr}`).join(`
+`);
+    const catalogInfo = context.catalog.map((attr) => `- ${attr.attribute}:${attr.type} e.g. ${attr.examples.join(", ")}`).join(`
+`);
+    const prompt = `You are an expert at converting natural language queries to EQL-S (EAV Query Language - Strict).
+
+Available attributes in the dataset:
+${catalogInfo}
+
+Attribute aliases you MUST use if the user mentions the alias term:
+${aliasInfo || "- (none)"}
+
+Data statistics: ${JSON.stringify(context.dataStats, null, 2)}
+
+EQL-S Grammar Rules:
+- Use FIND <type> AS ?var to specify entity type and variable
+- Use WHERE clause for conditions
+- Use RETURN clause to specify output fields
+- Use ORDER BY for sorting, LIMIT for result limits
+- Operators: = != > >= < <= BETWEEN ... AND ... CONTAINS MATCHES
+- For string pattern matching use MATCHES with regex patterns: MATCHES /pattern/
+- For "starts with", use MATCHES /^prefix/
+- For "ends with", use MATCHES /suffix$/
+- For "contains", use MATCHES /text/ or CONTAINS "text"
+- Regex literals must use forward slashes: /pattern/
+
+STRICT formatting rules for this dataset:
+- Entity type MUST be "default" unless explicitly specified. Use: FIND default AS ?e
+- Only use attribute names EXACTLY as listed above (e.g., ${attributes.slice(0, 3).join(", ")} ...). Do not invent attributes.
+- NEVER use numeric property access like ?e.0 or ?e.6 — that is invalid.
+- If the user refers to "question", "answer/response", or "reasoning/chain of thought",
+  use these attributes if available: ${[
+      questionAttr,
+      responseAttr,
+      cotAttr
+    ].filter(Boolean).join(", ") || "(none)"}
+
+Entity type detected: ${entityType || "item"}
+- Avoid using the IN operator for string matching
+- Variables must start with ? (e.g., ?p, ?user)
+- Strings must be in double quotes
+- Regex patterns should be in /pattern/ format but PREFER CONTAINS when possible
+
+Query Pattern Examples (adapt to available attributes):
+- "show me [entities] with more than X [numeric_attribute]" → FIND <type> AS ?e WHERE ?e.<attribute> > X RETURN ?e
+- "find [entities] containing [text]" → FIND <type> AS ?e WHERE ?e.<text_attribute> CONTAINS "text" RETURN ?e
+- "[entities] tagged with [value]" → FIND <type> AS ?e WHERE ?e.<tag_attribute> = "value" RETURN ?e
+- "[entities] between X and Y [units]" → FIND <type> AS ?e WHERE ?e.<numeric_attribute> BETWEEN X AND Y RETURN ?e
+- "[entities] that start with [prefix]" → FIND <type> AS ?e WHERE ?e.<text_attribute> MATCHES /^prefix/ RETURN ?e.<text_attribute>
+- "list [category] [entities]" → FIND <type> AS ?e WHERE ?e.<category_attribute> = "category" RETURN ?e
+
+Convert this natural language query to EQL-S: "${processedQuery}"
+
+Output ONLY the EQL-S query, no explanations or additional text.`;
+    const result = await generateText({
+      model: openai("gpt-4o-mini"),
+      prompt,
+      temperature: 0.1
+    });
+    let eqlsQuery = result.text.trim();
+    if (eqlsQuery.startsWith("```") && eqlsQuery.endsWith("```")) {
+      eqlsQuery = eqlsQuery.slice(3, -3).trim();
+      const firstLine = eqlsQuery.split(`
+`)[0];
+      if (firstLine && !firstLine.includes(" ") && firstLine.length < 20) {
+        eqlsQuery = eqlsQuery.split(`
+`).slice(1).join(`
+`).trim();
+      }
+    }
+    if (!eqlsQuery.startsWith("FIND")) {
+      return { error: "Generated query does not start with FIND" };
+    }
+    eqlsQuery = eqlsQuery.replace(/^(FIND)\s+([A-Za-z_][A-Za-z0-9_-]*)\s+AS\s+\?[A-Za-z_][A-Za-z0-9_]*/i, (m, findKw) => {
+      const varMatch = eqlsQuery.match(/AS\s+(\?[A-Za-z_][A-Za-z0-9_]*)/i);
+      const v = varMatch ? varMatch[1] : "?e";
+      return `${findKw} default AS ${v}`;
+    });
+    if (/\?[a-zA-Z_]\w*\.\d+/.test(eqlsQuery)) {
+      const wantsQuestion = /hallucinat|question|prompt/i.test(processedQuery);
+      const replacementAttr = wantsQuestion ? questionAttr : responseAttr || questionAttr || attributes[0];
+      if (replacementAttr) {
+        eqlsQuery = eqlsQuery.replace(/(\?[a-zA-Z_]\w*)\.\d+/g, `$1.${replacementAttr}`);
+      } else {
+        return { error: "Generated query used numeric property access (invalid)" };
+      }
+    }
+    const attrRefs = Array.from(eqlsQuery.matchAll(/\?[a-zA-Z_]\w*\.([A-Za-z0-9_.-]+)/g)).map((m) => m[1]).filter((a) => typeof a === "string");
+    const unknown = attrRefs.filter((a) => !attributes.includes(a));
+    if (unknown.length) {
+      let repaired = eqlsQuery;
+      for (const unk of unknown) {
+        const lower = unk.toLowerCase();
+        const alias = aliasPairs.find(({ alias: alias2 }) => lower.includes(alias2));
+        if (alias) {
+          repaired = repaired.replace(new RegExp(`(?[a-zA-Z_]\\w*.)${unk.replace(/[-/\\.^$*+?()|[\]{}]/g, "\\$&")}`, "g"), `$1${alias.attr}`);
+        }
+      }
+      if (repaired !== eqlsQuery) {
+        eqlsQuery = repaired;
+      }
+    }
+    return { eqlsQuery };
+  } catch (error) {
+    return {
+      error: `Failed to process query: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+};
+function identifyEntityType(query) {
+  const normalizedQuery = query.toLowerCase();
+  const entityPatterns = [
+    /(?:find|show|list|get|search)\s+([a-z]+s?)\b/i,
+    /\b([a-z]+s?)\s+(?:that|with|containing|having)\b/i,
+    /\b([a-z]+s?)'?s?\s+[a-z]+/i
+  ];
+  for (const pattern of entityPatterns) {
+    const match = normalizedQuery.match(pattern);
+    if (match && match[1]) {
+      let entityType = match[1].toLowerCase();
+      if (entityType.endsWith("ies")) {
+        entityType = entityType.slice(0, -3) + "y";
+      } else if (entityType.endsWith("es")) {
+        entityType = entityType.slice(0, -2);
+      } else if (entityType.endsWith("s") && entityType.length > 3) {
+        entityType = entityType.slice(0, -1);
+      }
+      const excludeWords = ["this", "that", "the", "and", "or", "but", "with", "from", "by", "at", "in", "on", "to", "for", "of", "as", "is", "are", "was", "were", "be", "been", "have", "has", "had", "do", "does", "did", "will", "would", "could", "should", "may", "might", "can", "all", "any", "some", "more", "most", "less", "least", "first", "last", "next", "previous"];
+      if (!excludeWords.includes(entityType) && entityType.length > 2) {
+        return entityType;
+      }
+    }
+  }
+  return "item";
+}
+function handleCommonPatterns(query) {
+  let normalizedQuery = query.trim().toLowerCase();
+  if (normalizedQuery.includes("start with") || normalizedQuery.includes("starts with") || normalizedQuery.includes("beginning with") || normalizedQuery.includes("begins with")) {
+    const pattern = /(?:starts?|begins?|beginning) with\s+(?:the letter\s+)?['"]?([a-zA-Z0-9]+)['"]?/i;
+    const match = query.match(pattern);
+    if (match && match[1]) {
+      const prefix = match[1];
+      normalizedQuery = normalizedQuery.replace(/(?:starts?|begins?|beginning) with\s+(?:the letter\s+)?['"]?([a-z0-9]+)['"]?/i, `matches /^${prefix}/`);
+    }
+  }
+  if (normalizedQuery.includes("end with") || normalizedQuery.includes("ends with") || normalizedQuery.includes("ending with")) {
+    const pattern = /(?:ends?|ending) with\s+(?:the letter\s+)?['"]?([a-zA-Z0-9]+)['"]?/i;
+    const match = query.match(pattern);
+    if (match && match[1]) {
+      const suffix = match[1];
+      normalizedQuery = normalizedQuery.replace(/(?:ends?|ending) with\s+(?:the letter\s+)?['"]?([a-z0-9]+)['"]?/i, `matches /${suffix}$/`);
+    }
+  }
+  if (normalizedQuery.includes("contain") || normalizedQuery.includes("having") || normalizedQuery.includes("with") && normalizedQuery.includes("in the name")) {
+    const patterns = [
+      /containing\s+(?:the text\s+)?['"]([^'"]+)['"]/i,
+      /contains\s+(?:the text\s+)?['"]([^'"]+)['"]/i,
+      /with\s+['"]([^'"]+)['"]\s+in the (?:name|title|text)/i,
+      /having\s+['"]([^'"]+)['"]\s+in/i
+    ];
+    for (const pattern of patterns) {
+      const match = query.match(pattern);
+      if (match && match[1]) {
+        const text = match[1];
+        normalizedQuery = normalizedQuery.replace(pattern, `matches /${text}/`);
+        break;
+      }
+    }
+  }
+  return normalizedQuery;
+}
+
+// src/ai/nl-query-provider.ts
+class DefaultNLQueryProvider {
+  options;
+  name = "default-orchestrator";
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async translate(nl, context) {
+    const catalog = context?.catalog || this.options.catalog || [];
+    const dataStats = context?.dataStats || this.options.dataStats || { totalFacts: 0 };
+    const result = await processQuery(nl, { catalog, dataStats });
+    if (result.error) {
+      throw new Error(`NL translation failed: ${result.error}`);
+    }
+    if (!result.eqlsQuery) {
+      throw new Error("NL translation failed: no query generated");
+    }
+    return result.eqlsQuery;
+  }
+}
+export {
+  quickOrchestrate,
+  orchestrate,
+  generateResponse,
+  analyzeIntent,
+  DefaultNLQueryProvider
+};