glitool 1.0.1 → 2.0.1

package/dist/agents/refactorer.js

@@ -0,0 +1,97 @@
+import { makeLlm } from '../llm/factory.js';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { SystemMessage, HumanMessage } from '@langchain/core/messages';
+import { listFilesTool, readFileTool, searchCodeTool, bashTool, editFileTool, } from '../tools/index.js';
+const REFACTOR_SYSTEM_PROMPT = `You are a refactoring agent. You change shape, never behavior.
+
+Strict rules:
+- You can read, search, run shell commands, and edit existing files. You CANNOT create new files.
+- Refactoring = structural change with identical behavior. Examples allowed: rename, extract function, dedupe, reorder, split a file. Examples NOT allowed: change a return value, add a new feature, change error handling semantics, change defaults.
+- If the user asks for a behavior change, refuse and tell them to use /coder.
+- Tests are the contract. If they fail, you revert everything.
+
+Required workflow (do these in order):
+
+HARD STOP CONDITIONS:
+- If tests don't exist AND no TypeScript files are present, refuse — there's no way to verify behavior. Tell the user to add tests first via /coder. (If TypeScript files exist, fall through to step 2's tsc-only guard.)
+- If you've made more than 5 edits without re-running tests, STOP and re-run tests now.
+- Total tool calls per run: maximum 15. If you reach 12, wrap up.
+
+1. CHECKPOINT
+   - Run \`git status --porcelain\` via bash.
+   - If output is NOT empty, stop and tell the user: "Working tree must be clean before refactoring. Commit or stash your changes first." Do not edit anything.
+
+2. READ + BASELINE
+   - Read each target file with readFile.
+   - Detect the test command: look for "test" script in package.json (cat package.json | bash), else try \`npm test\`, \`vitest run\`, \`jest\`, \`pnpm test\`. Skip type-checking; use the project's actual test runner.
+   - Run the tests once via bash. Save the result:
+     - All pass → continue
+     - Some fail → stop and tell the user "Tests are already failing before refactor — fix those first or use /debug."
+     - No tests at all → warn user explicitly: "No tests found. I will run \`npx tsc --noEmit\` as a weaker guard, but I cannot prove behavior is preserved."
+
+3. PLAN
+   Output a short plan BEFORE editing:
+
+   ## Plan
+   - file.ts: rename X → Y
+   - file.ts: extract function Z out of W
+   (one bullet per structural change)
+
+4. APPLY
+   - Use editFile for each change. Keep edits minimal and structural.
+
+5. VERIFY
+   - Re-run the same test command from step 2.
+
+6. DECIDE
+   - Tests pass → done. Show \`git diff --stat\` summary.
+   - Tests fail → run \`git checkout -- <each changed file>\` via bash to REVERT every edit. Then explain what broke and why. Do not try to fix forward.
+
+Final response format on SUCCESS:
+
+## Refactor complete
+- summary of structural changes
+- test result: pass
+- files changed: <git diff --stat output>
+
+Final response format on FAILURE:
+
+## Refactor reverted
+- what you tried
+- what broke (failing test names + first error line)
+- working tree restored — \`git status\` should be clean again`;
+export async function runRefactorer(userMessage, onToolCall, model) {
+    const llm = makeLlm(model);
+    const tools = [
+        listFilesTool,
+        readFileTool,
+        searchCodeTool,
+        bashTool,
+        editFileTool,
+    ];
+    const agent = createReactAgent({
+        llm,
+        tools,
+        stateModifier: new SystemMessage(REFACTOR_SYSTEM_PROMPT),
+    });
+    let finalText = '';
+    const stream = agent.streamEvents({ messages: [new HumanMessage(userMessage)] }, { version: 'v2', recursionLimit: 50 });
+    for await (const { event, data, name: eventName } of stream) {
+        if (event === 'on_tool_start') {
+            onToolCall(eventName, data.input);
+        }
+        if (event === 'on_chat_model_end') {
+            const output = data.output;
+            if (typeof output?.content === 'string') {
+                finalText = output.content;
+            }
+            else if (Array.isArray(output?.content)) {
+                finalText = output.content
+                    .filter((c) => c.type === 'text')
+                    .map((c) => c.text ?? '')
+                    .join('');
+            }
+        }
+    }
+    return finalText || 'Refactorer produced no output.';
+}

package/dist/agents/reviewer-agent.js

@@ -0,0 +1,87 @@
+import { makeLlm } from '../llm/factory.js';
+import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { SystemMessage, HumanMessage } from '@langchain/core/messages';
+import { listFilesTool, readFileTool, searchCodeTool, bashTool } from '../tools/index.js';
+import { log } from '../logger.js';
+const REVIEW_SYSTEM_PROMPT = `You are a read-only code review agent.
+
+Your job: analyze the user's target files and return a structured report.
+
+HARD STOP CONDITIONS:
+- After reading the target file(s) and running tsc/eslint once, you have all the data you need — produce the report. Do not re-read files or re-run analyses.
+- Total tool calls per run: maximum 8.
+
+
+Strict rules:
+- You cannot write or edit any file. You have no writeFile / editFile tool.
+- If the user asks you to fix or refactor anything, refuse and tell them to use /coder or /refactor instead.
+- Be specific: cite file paths and line numbers when possible.
+- Severity guide:
+  - CRITICAL: bugs, security holes, type errors, runtime crashes
+  - WARNING: bad practice, missing error handling, unclear logic, dead code
+  - SUGGESTION: style, naming, small improvements, doc gaps
+
+Workflow:
+1. If the user named files, read them with readFile.
+   If they said "this project" or similar, use listFiles + searchCode to find relevant files first.
+2. Run \`npx tsc --noEmit\` via the bash tool and capture type errors.
+3. Run \`npx eslint <changed-files>\` via the bash tool (skip if eslint isn't configured).
+4. Read the files. Combine static-analysis output with your own reading.
+5. Return a markdown report in EXACTLY this shape:
+
+## Summary
+<one or two sentences — overall health>
+
+## Issues
+
+### CRITICAL
+- file.ts:LINE — what is wrong and why it matters
+
+### WARNING
+- file.ts:LINE — what is wrong and how to think about it
+
+### SUGGESTION
+- file.ts:LINE — small improvement
+
+## What's good
+- one or two things the code does well
+
+If a section has no items, write "none" under its heading. Do not omit sections.
+
+TERMINAL OUTPUT RULES — these override everything else about formatting:
+- No markdown headers (no ##, no ###). Use plain uppercase labels: SUMMARY, CRITICAL, WARNING, SUGGESTION, GOOD.
+- No **bold** or *italic*. Plain text only.
+- No bullet dashes longer than needed — one short line per issue.
+- Each issue: filename:LINE — one sentence max.
+- Total response: 25 lines maximum. Cut low-value suggestions if needed to stay under.`;
+export async function runReviewer(userMessage, onToolCall, model) {
+    const llm = makeLlm(model);
+    const tools = [listFilesTool, readFileTool, searchCodeTool, bashTool];
+    const agent = createReactAgent({
+        llm,
+        tools,
+        stateModifier: new SystemMessage(REVIEW_SYSTEM_PROMPT),
+    });
+    let finalText = '';
+    const stream = agent.streamEvents({ messages: [new HumanMessage(userMessage)] }, { version: 'v2', recursionLimit: 50 });
+    for await (const { event, data, name: eventName } of stream) {
+        if (event === 'on_tool_start') {
+            onToolCall(eventName, data.input);
+            log('review:tool', { tool: eventName, input: JSON.stringify(data.input).slice(0, 80) });
+        }
+        if (event === 'on_chat_model_end') {
+            const output = data.output;
+            if (typeof output?.content === 'string') {
+                finalText = output.content;
+            }
+            else if (Array.isArray(output?.content)) {
+                finalText = output.content
+                    .filter((c) => c.type === 'text')
+                    .map((c) => c.text ?? '')
+                    .join('');
+            }
+        }
+    }
+    log('review:done', { lines: finalText.split('\n').length });
+    return finalText || 'Review produced no output.';
+}

package/dist/agents/reviewer.js

@@ -1,17 +1,14 @@
-import { ChatOpenAI } from "@langchain/openai";
+// REPLACE the whole file with:
+import { makeLlm } from '../llm/factory.js';
 import { SystemMessage, HumanMessage } from "@langchain/core/messages";
-const reviewerLlm = new ChatOpenAI({
-    model: 'gpt-5.4-mini',
-    apiKey: process.env.OPENAI_API_KEY
-});
-export async function runReviewer(plan, coderOutput, userMessage) {
-    const response = await reviewerLlm.invoke([
+export async function runReviewer(plan, coderOutput, userMessage, model) {
+    const llm = makeLlm(model);
+    const response = await llm.invoke([
         new SystemMessage(`You are a code reviewer. check if the coder's work correctly fulfills the user's request. Return valid JSON only:
             {
-                "approved":true or false,
+                "approved": true or false,
                 "feedback": "what needs fixing if not approved, otherwise empty string",
                 "finalResponse": "the final message to show the user summarizing what was done"
-            
             }`),
         new HumanMessage(`User request: ${userMessage}\n\nPlan:\n${plan}\n\nWhat was done:\n${coderOutput}`)
     ]);

package/dist/agents/types.js

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

package/dist/agents/validator.js

@@ -0,0 +1,93 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import fg from 'fast-glob';
+function runCommand(cmd, args, cwd, timeoutMs = 60_000) {
+    return new Promise(resolve => {
+        const proc = spawn(cmd, args, { cwd, timeout: timeoutMs, shell: true });
+        let stdout = '', stderr = '';
+        proc.stdout?.on('data', d => { stdout += d.toString(); });
+        proc.stderr?.on('data', d => { stderr += d.toString(); });
+        proc.on('close', code => resolve({ ok: code === 0, stdout, stderr }));
+        proc.on('error', err => resolve({ ok: false, stdout, stderr: err.message }));
+    });
+}
+async function findTsConfigs() {
+    // Walk down from cwd (max 2 levels deep) to find tsconfig.json files,
+    // ignoring node_modules / dist / .next / .git
+    return fg(['tsconfig.json', '*/tsconfig.json', '*/*/tsconfig.json'], {
+        cwd: process.cwd(),
+        ignore: ['node_modules/**', 'dist/**', '.next/**', '.git/**', 'build/**'],
+        onlyFiles: true,
+        suppressErrors: true,
+    });
+}
+async function findEslintConfigs() {
+    return fg([
+        '.eslintrc.json', '.eslintrc.js', '.eslintrc.cjs', 'eslint.config.js',
+        '*/.eslintrc.json', '*/.eslintrc.js', '*/eslint.config.js',
+    ], {
+        cwd: process.cwd(),
+        ignore: ['node_modules/**', 'dist/**', '.git/**'],
+        onlyFiles: true,
+        suppressErrors: true,
+    });
+}
+const MAX_ERROR_LINES = 30;
+export async function runValidator() {
+    const result = {
+        tsc: { ok: true, errors: [], ran: false },
+        eslint: { ok: true, errors: [], ran: false },
+        overallOk: true,
+    };
+    const tsConfigs = await findTsConfigs();
+    if (tsConfigs.length === 0) {
+        result.tsc = { ok: true, errors: [], ran: false };
+        result.overallOk = true;
+        return result;
+    }
+    for (const cfg of tsConfigs) {
+        result.tsc.ran = true;
+        const projectDir = path.dirname(path.resolve(process.cwd(), cfg));
+        const tscRes = await runCommand('npx', ['tsc', '--noEmit'], projectDir);
+        if (!tscRes.ok) {
+            const lines = (tscRes.stdout + tscRes.stderr)
+                .split('\n')
+                .map(l => l.trim())
+                .filter(l => l.length > 0 && /error TS\d+/i.test(l));
+            if (lines.length > 0) {
+                result.tsc.ok = false;
+                result.tsc.errors.push(`[${cfg}]`, ...lines.slice(0, MAX_ERROR_LINES));
+            }
+        }
+    }
+    const eslintConfigs = await findEslintConfigs();
+    for (const cfg of eslintConfigs) {
+        result.eslint.ran = true;
+        const projectDir = path.dirname(path.resolve(process.cwd(), cfg));
+        const eslintRes = await runCommand('npx', ['eslint', '.', '--format', 'compact'], projectDir);
+        if (!eslintRes.ok) {
+            const lines = (eslintRes.stdout + eslintRes.stderr)
+                .split('\n')
+                .map(l => l.trim())
+                .filter(l => l.length > 0 && !l.startsWith('npm '))
+                .filter(l => /error|warning/i.test(l));
+            if (lines.length > 0) {
+                result.eslint.ok = false;
+                result.eslint.errors.push(`[${cfg}]`, ...lines.slice(0, MAX_ERROR_LINES));
+            }
+        }
+    }
+    result.overallOk = result.tsc.ok && result.eslint.ok;
+    return result;
+}
+export function formatValidationErrors(v) {
+    const parts = [];
+    if (!v.tsc.ran)
+        parts.push('No tsconfig found — TypeScript was not validated. Treat output as UNVERIFIED.');
+    if (!v.tsc.ok)
+        parts.push(`TypeScript errors:\n${v.tsc.errors.join('\n')}`);
+    if (!v.eslint.ok)
+        parts.push(`ESLint errors:\n${v.eslint.errors.join('\n')}`);
+    return parts.join('\n\n');
+}

package/dist/agents/workflow.js

@@ -0,0 +1,45 @@
+export function buildTopology(steps) {
+    const levelMap = new Map();
+    function getLevel(id) {
+        if (levelMap.has(id))
+            return levelMap.get(id);
+        const step = steps.find(s => s.id === id);
+        if (!step || step.depends_on.length === 0) {
+            levelMap.set(id, 0);
+            return 0;
+        }
+        const level = Math.max(...step.depends_on.map(getLevel)) + 1;
+        levelMap.set(id, level);
+        return level;
+    }
+    steps.forEach(s => getLevel(s.id));
+    const byLevel = new Map();
+    for (const [id, level] of levelMap) {
+        if (!byLevel.has(level))
+            byLevel.set(level, []);
+        byLevel.get(level).push(id);
+    }
+    const groups = [...byLevel.keys()]
+        .sort((a, b) => a - b)
+        .map(level => {
+        const stepIds = byLevel.get(level);
+        return { type: stepIds.length > 1 ? `parallel` : `seq`, stepIds };
+    });
+    return { groups };
+}
+export function formatTopologyAsPlan(topology, steps) {
+    return topology.groups.map((group, i) => {
+        const label = group.type === 'parallel' ? `Group ${i + 1} - run in parallel` : `Group ${i + 1}`;
+        const lines = group.stepIds.map(id => {
+            const step = steps.find(s => s.id === id);
+            return step ? `  Step ${step.id} [${step.action}]\n    Why: ${step.why}`
+                : `  Step ${id}`;
+        });
+        return `${label}:\n${lines.join('\n')}`;
+    }).join(`\n\n`);
+}
+export function topologySummary(topology) {
+    const parallel = topology.groups.filter(g => g.type === 'parallel').length;
+    const total = topology.groups.length;
+    return `${total} group${total !== 1 ? 's' : ''}, ${parallel} parallel`;
+}

package/dist/auth.js

@@ -0,0 +1,87 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+import { randomUUID } from 'crypto';
+const GLITOOL_DIR = join(os.homedir(), '.glitool');
+const ANON_FILE = join(GLITOOL_DIR, 'anon.json');
+const AUTH_FILE = join(GLITOOL_DIR, 'auth.json');
+const BACKEND_URL = process.env.GLITOOL_BACKEND ?? 'https://api.glit.in';
+export const ANON_LIMIT = 5;
+function ensureDir() {
+    mkdirSync(GLITOOL_DIR, { recursive: true });
+}
+function readAnon() {
+    ensureDir();
+    if (!existsSync(ANON_FILE)) {
+        const data = {
+            uuid: randomUUID(),
+            requestCount: 0,
+            createdAt: new Date().toISOString(),
+        };
+        writeFileSync(ANON_FILE, JSON.stringify(data, null, 2), 'utf-8');
+        return data;
+    }
+    try {
+        return JSON.parse(readFileSync(ANON_FILE, 'utf-8'));
+    }
+    catch {
+        const data = { uuid: randomUUID(), requestCount: 0, createdAt: new Date().toISOString() };
+        writeFileSync(ANON_FILE, JSON.stringify(data, null, 2), 'utf-8');
+        return data;
+    }
+}
+function writeAnon(data) {
+    ensureDir();
+    writeFileSync(ANON_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+export function getOrCreateAnonId() {
+    return readAnon().uuid;
+}
+export function getAnonRequestCount() {
+    return readAnon().requestCount;
+}
+export function incrementAnonCount() {
+    const data = readAnon();
+    data.requestCount += 1;
+    writeAnon(data);
+    return data.requestCount;
+}
+export function isAnonLimitReached() {
+    return readAnon().requestCount >= ANON_LIMIT;
+}
+export function readAuth() {
+    ensureDir();
+    if (!existsSync(AUTH_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(AUTH_FILE, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveAuth(data) {
+    ensureDir();
+    writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), 'utf-8');
+}
+export function getAuthToken() {
+    return readAuth()?.token ?? null;
+}
+export function isAuthenticated() {
+    return !!readAuth()?.token;
+}
+export async function startDeviceFlow() {
+    const res = await fetch(`${BACKEND_URL}/auth/device`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+    });
+    if (!res.ok)
+        throw new Error(`Server error: ${res.status}`);
+    return res.json();
+}
+export async function pollDeviceFlow(deviceCode) {
+    const res = await fetch(`${BACKEND_URL}/auth/device/poll?device_code=${deviceCode}`);
+    if (!res.ok)
+        throw new Error(`Poll error: ${res.status}`);
+    return res.json();
+}

package/dist/commands/version.js

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

package/dist/config.js

@@ -6,7 +6,10 @@ const DEFAULTS = {
     name: 'Developer',
     preferredLanguage: 'TypeScript',
     codingStyle: 'spaces',
-    preferredModel: 'gpt-4o-mini'
+    preferredModel: 'meta-llama/Llama-3.3-70B-Instruct-Turbo',
+    routing: {
+        useLlmClassifier: true,
+    },
 };
 export function loadConfig() {
     try {

package/dist/confirmHandler.js

@@ -1,7 +1,9 @@
+import { log } from "./logger.js";
 let handler = async () => true;
 export function setConfirmHandler(fn) {
     handler = fn;
 }
-export function requestConfirm(message) {
-    return handler(message);
+export async function requestConfirm(req) {
+    log('confirm:requested', { filePath: req.filePath, type: req.type });
+    return handler(req);
 }

package/dist/index.js

@@ -12,9 +12,9 @@ import { generateAndSaveSummary } from "./memory.js";
 import { llm, sessionMessages } from "./agent.js";
 import { extractAndSaveProjectMemory } from "./projectMemory.js";
 import os from 'os';
-import { createInflate } from "zlib";
-import { mkdirSync, writeFileSync, existsSync } from 'fs';
-import { createInterface } from "readline";
+// import { mkdirSync, writeFileSync, existsSync } from 'fs';
+// import { createInterface } from "readline";
+import { mkdirSync, existsSync } from 'fs';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 dotenvConfig({ path: join(os.homedir(), '.glitool', '.env') });
@@ -65,30 +65,17 @@ program
 });
 async function ensureApiKey() {
     if (process.env.OPENAI_API_KEY)
-        return;
-    const envPath = join(os.homedir(), '.glitool', '.env');
-    if (existsSync(envPath)) {
-        dotenvConfig({ path: envPath });
-        if (process.env.OPENAI_API_KEY)
-            return;
-    }
-    console.log('\nNo OpenAI API key found.');
-    console.log('Get one at https://platform.openai.com/api-keys\n');
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const key = await new Promise(resolve => rl.question('Paste your API key: ', resolve));
-    rl.close();
-    if (!key.trim()) {
-        console.log('No key entered. Exiting.');
-        process.exit(1);
-    }
-    mkdirSync(join(os.homedir(), '.glitool'), { recursive: true });
-    writeFileSync(envPath, `OPENAI_API_KEY=${key.trim()}\n`, 'utf-8');
-    process.env.OPENAI_API_KEY = key.trim();
-    console.log('API key saved to ~/.glitool/.env\n');
+        return; // BYOK mode — use OpenAI directly
+    // Otherwise Glitool backend handles auth (anon trial or glt_ token)
 }
 const saveAndExit = async () => {
-    await generateAndSaveSummary(sessionMessages, llm);
-    await extractAndSaveProjectMemory(sessionMessages, llm);
+    try {
+        await generateAndSaveSummary(sessionMessages, llm);
+        await extractAndSaveProjectMemory(sessionMessages, llm);
+    }
+    catch {
+        // exit cleanly even if LLM is unreachable
+    }
     process.exit(0);
 };
 process.on('SIGINT', saveAndExit);

package/dist/llm/classifier.js

@@ -0,0 +1,61 @@
+import { makeLlm } from './factory.js';
+import { SystemMessage, HumanMessage } from "@langchain/core/messages";
+import { makeInternalLlm } from './factory.js';
+const VALID_DOMAINS = [
+    'chat', 'coding', 'explanation', 'planning', 'debugging', 'refactoring', 'review', 'git'
+];
+const classifierLlm = makeInternalLlm('gpt-4o-mini', {
+    temperature: 0,
+    modelKwargs: { response_format: { type: 'json_object' } },
+});
+export async function classifyWithLlm(prompt, recentMessages) {
+    try {
+        const history = recentMessages.slice(-6).map(m => {
+            const role = m._getType() === 'human' ? 'User' : 'Assistant';
+            const text = (typeof m.content === 'string' ? m.content : '').slice(0, 300);
+            return `${role}: ${text}`;
+        }).join('\n').slice(0, 1000);
+        const response = await classifierLlm.invoke([
+            new SystemMessage(`You are a routing classifier for a coding assistant CLI.
+Classify the user's message into exactly ONE domain. Use the conversation history to resolve pronouns and references.
+
+CRITICAL: Classify by the user's INTENT, not by words appearing in file paths or identifiers. A file named "git-agent.ts" being mentioned does NOT make the request a git task. "agent" in a path does NOT mean coding. Look at the verb and what the user wants to happen.
+
+Domains:
+- chat: greetings, opinions, casual questions with no file or code operation needed. Examples: "hi", "thanks", "what do you think about X".
+- explanation: the user wants to UNDERSTAND something that already exists. Reading a file, summarizing code, explaining what a function does. Examples: "read router.ts", "what does this function do", "show me package.json", "how does auth work here".
+- coding: the user wants to CREATE or MODIFY code to add functionality. New features, new files, new logic. Examples: "build a todo CLI", "add a login route", "implement caching".
+- debugging: the user has an ERROR, crash, failing test, or broken behavior they want fixed. Examples: "fix this crash", "tests are failing", "why does X throw".
+- refactoring: the user wants STRUCTURAL change with identical behavior. Rename, extract, dedupe, simplify. Examples: "clean up router.ts", "extract this into a helper", "rename X to Y".
+- review: the user wants a READ-ONLY audit or quality assessment. Examples: "review my router", "any security issues here", "is this code good".
+- planning: the user wants a DESIGN DOCUMENT or roadmap written to plan.md. Examples: "plan a payment system", "design the auth flow", "roadmap for v2".
+- git: ONLY for actual git/version-control operations — commit, diff, push, pull, branch, log, status, stash. Reading source files via paths like "src/foo.ts" is NEVER git, even when the filename contains the word "git". Examples: "commit my changes", "what's on this branch", "write a commit message".
+
+Tie-breakers:
+- "read/show/open/cat/view <path>" → explanation
+- "fix <error>" → debugging
+- "add/build/create <feature>" → coding
+- "clean up/refactor/rename <code>" → refactoring
+- "review/audit/check <code>" → review
+- "plan/design/roadmap <thing>" → planning
+- starts with the literal word "git" → git
+- short greeting or opinion question → chat
+
+Return JSON: {"domain":"<domain>","confidence":"high" or "low", "reason":"<one sentence>"}`),
+            new HumanMessage(history ? `Conversation so far:\n${history}\n\nNew message: ${prompt}` : `Message: ${prompt}`)
+        ], { timeout: 3000 });
+        const raw = typeof response.content === 'string' ? response.content : '';
+        const parsed = JSON.parse(raw);
+        if (!VALID_DOMAINS.includes(parsed.domain))
+            return null;
+        return {
+            domain: parsed.domain,
+            confidence: parsed.confidence === 'high' ? 'high' : 'low',
+            reason: parsed.reason ?? '',
+            tokens: response.usage_metadata?.total_tokens ?? 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/llm/factory.js

@@ -0,0 +1,58 @@
+import { ChatOpenAI } from '@langchain/openai';
+import { randomUUID } from 'crypto';
+import { getAuthToken, getOrCreateAnonId } from '../auth.js';
+const BACKEND_URL = process.env.GLITOOL_BACKEND ?? 'https://api.glit.in';
+let currentRequestId = null;
+export function startNewRequest() {
+    currentRequestId = randomUUID();
+    return currentRequestId;
+}
+function requestIdHeader() {
+    return currentRequestId ? { 'X-Glitool-Request-ID': currentRequestId } : {};
+}
+export function makeLlm(model, extras = {}) {
+    if (process.env.OPENAI_API_KEY) {
+        return new ChatOpenAI({ model, apiKey: process.env.OPENAI_API_KEY, ...extras });
+    }
+    const token = getAuthToken();
+    if (token) {
+        return new ChatOpenAI({
+            model,
+            apiKey: token,
+            configuration: {
+                baseURL: `${BACKEND_URL}/v1`,
+                defaultHeaders: requestIdHeader(),
+            },
+            ...extras,
+        });
+    }
+    return new ChatOpenAI({
+        model,
+        apiKey: 'anon',
+        configuration: {
+            baseURL: `${BACKEND_URL}/v1`,
+            defaultHeaders: { 'X-Anon-ID': getOrCreateAnonId(), ...requestIdHeader() },
+        },
+        ...extras,
+    });
+}
+export function makeInternalLlm(model, extras = {}) {
+    if (process.env.OPENAI_API_KEY) {
+        return new ChatOpenAI({ model, apiKey: process.env.OPENAI_API_KEY, ...extras });
+    }
+    const token = getAuthToken();
+    const anonHeaders = token ? {} : { 'X-Anon-ID': getOrCreateAnonId() };
+    return new ChatOpenAI({
+        model,
+        apiKey: token ?? 'anon',
+        configuration: {
+            baseURL: `${BACKEND_URL}/v1`,
+            defaultHeaders: {
+                ...anonHeaders,
+                'X-Glitool-Internal': 'true',
+                ...requestIdHeader(),
+            },
+        },
+        ...extras,
+    });
+}