trapic-mcp 0.1.0

package/bin/wrapper.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+echo "$(date) WRAPPER CALLED pid=$$ args=$*" >> "$HOME/.trapic-mcp/wrapper.log"
+echo "$(date) ENV TRAPIC_TOKEN=${TRAPIC_TOKEN:0:8}..." >> "$HOME/.trapic-mcp/wrapper.log"
+mkdir -p "$HOME/.trapic-mcp"
+exec node "/Users/wongkimhong/ai/trace-mcp/bin/trapic-mcp.mjs" "$@"

package/dist/archive.d.ts

@@ -0,0 +1,7 @@
+interface ArchiveEnv {
+    SUPABASE_URL: string;
+    SUPABASE_SERVICE_ROLE_KEY: string;
+    ARCHIVE_BUCKET: R2Bucket;
+}
+export declare function runArchive(env: ArchiveEnv): Promise<string>;
+export {};

package/dist/archive.js

@@ -0,0 +1,116 @@
+/**
+ * Daily archive: move traces older than 30 days from Supabase to R2
+ * Then delete archived traces after 7-day safety buffer
+ */
+import { createClient } from "@supabase/supabase-js";
+const BATCH_SIZE = 500;
+const FREE_ARCHIVE_DAYS = 30; // matches config/plans.ts free.archiveDays
+const DELETE_AFTER_DAYS = 7; // days after archiving before deletion
+export async function runArchive(env) {
+    const supabase = createClient(env.SUPABASE_URL, env.SUPABASE_SERVICE_ROLE_KEY);
+    const now = new Date();
+    const logs = [];
+    // Get team member user IDs — they have longer archive retention (pro/team plans)
+    // TODO: When Stripe is integrated, check user_subscriptions for plan-specific archiveDays
+    const { data: teamUsers } = await supabase
+        .from("team_members")
+        .select("user_id");
+    const teamUserIds = new Set((teamUsers ?? []).map((r) => r.user_id));
+    // ── Step 1: Archive free-plan traces older than 30 days ──
+    // Skip users who are in teams (they have pro/team plan with longer retention)
+    const archiveCutoff = new Date(now);
+    archiveCutoff.setDate(archiveCutoff.getDate() - FREE_ARCHIVE_DAYS);
+    const cutoffISO = archiveCutoff.toISOString();
+    let totalArchived = 0;
+    let hasMore = true;
+    while (hasMore) {
+        const { data: traces, error } = await supabase
+            .from("traces")
+            .select("*")
+            .lt("created_at", cutoffISO)
+            .is("archived_at", null)
+            .order("created_at", { ascending: true })
+            .limit(BATCH_SIZE);
+        if (error) {
+            logs.push(`Error fetching traces: ${error.message}`);
+            break;
+        }
+        if (!traces || traces.length === 0) {
+            hasMore = false;
+            break;
+        }
+        // Skip traces belonging to team members (they have longer retention)
+        const archivable = traces.filter((t) => !teamUserIds.has(t.author));
+        if (archivable.length === 0) {
+            hasMore = traces.length >= BATCH_SIZE;
+            continue;
+        }
+        // Group by user_id and date for organized storage
+        const groups = new Map();
+        for (const trace of archivable) {
+            const date = trace.created_at.slice(0, 10); // YYYY-MM-DD
+            const key = `${trace.author}/${date}`;
+            if (!groups.has(key))
+                groups.set(key, []);
+            groups.get(key).push(trace);
+        }
+        // Write each group to R2
+        for (const [key, groupTraces] of groups) {
+            const [userId, date] = key.split("/");
+            const [year, month, day] = date.split("-");
+            const r2Key = `archives/${userId}/${year}/${month}/${day}.ndjson`;
+            // Append to existing file if it exists
+            const existing = await env.ARCHIVE_BUCKET.get(r2Key);
+            let content = existing ? await existing.text() : "";
+            for (const trace of groupTraces) {
+                content += JSON.stringify(trace) + "\n";
+            }
+            await env.ARCHIVE_BUCKET.put(r2Key, content, {
+                httpMetadata: { contentType: "application/x-ndjson" },
+                customMetadata: {
+                    userId,
+                    date,
+                    traceCount: String(content.split("\n").filter(Boolean).length),
+                },
+            });
+        }
+        // Mark as archived in Supabase
+        const ids = archivable.map((t) => t.id);
+        const { error: updateErr } = await supabase
+            .from("traces")
+            .update({ archived_at: now.toISOString() })
+            .in("id", ids);
+        if (updateErr) {
+            logs.push(`Error marking archived: ${updateErr.message}`);
+            break;
+        }
+        totalArchived += archivable.length;
+        if (traces.length < BATCH_SIZE) {
+            hasMore = false;
+        }
+    }
+    if (totalArchived > 0) {
+        logs.push(`Archived ${totalArchived} traces to R2`);
+    }
+    // ── Step 2: Delete traces archived more than 7 days ago ──
+    const deleteCutoff = new Date(now);
+    deleteCutoff.setDate(deleteCutoff.getDate() - DELETE_AFTER_DAYS);
+    const deleteCutoffISO = deleteCutoff.toISOString();
+    const { count, error: deleteErr } = await supabase
+        .from("traces")
+        .delete({ count: "exact" })
+        .not("archived_at", "is", null)
+        .lt("archived_at", deleteCutoffISO);
+    if (deleteErr) {
+        logs.push(`Error deleting old archived traces: ${deleteErr.message}`);
+    }
+    else if (count && count > 0) {
+        logs.push(`Deleted ${count} archived traces from Supabase (archived >${DELETE_AFTER_DAYS}d ago)`);
+    }
+    // ── Step 3: Clean up orphaned context links ──
+    const { error: cleanupErr } = await supabase.rpc("cleanup_orphaned_context_links");
+    if (cleanupErr && !cleanupErr.message.includes("does not exist")) {
+        logs.push(`Context link cleanup error: ${cleanupErr.message}`);
+    }
+    return logs.length > 0 ? logs.join("\n") : "No traces to archive or delete";
+}

package/dist/audit.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Audit logging — fire-and-forget, never blocks main flow.
+ */
+export type AuditAction = "trace.create" | "trace.read" | "trace.update" | "trace.delete" | "trace.search" | "trace.summary" | "context.read" | "context.find" | "context.link" | "team.create" | "team.invite" | "team.join" | "team.leave" | "team.remove";
+export declare function audit(userId: string, action: AuditAction, resourceType: string, resourceId?: string, metadata?: Record<string, unknown>): void;

package/dist/audit.js

@@ -0,0 +1,16 @@
+/**
+ * Audit logging — fire-and-forget, never blocks main flow.
+ */
+import { getSupabase } from "./supabase.js";
+import { runBackground } from "./background.js";
+export function audit(userId, action, resourceType, resourceId, metadata) {
+    const supabase = getSupabase();
+    const p = supabase.rpc("insert_audit_log", {
+        p_user_id: userId,
+        p_action: action,
+        p_resource_type: resourceType,
+        p_resource_id: resourceId ?? null,
+        p_metadata: metadata ?? {},
+    }).then(() => { }, (err) => console.error("[audit]", err.message));
+    runBackground(Promise.resolve(p));
+}

package/dist/background.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Global background task holder for Cloudflare Workers.
+ * Worker sets ctx.waitUntil via setWaitUntil() at request start,
+ * then any module can call runBackground() to keep promises alive
+ * after the Response is sent.
+ */
+export declare function setWaitUntil(fn: (p: Promise<unknown>) => void): void;
+export declare function runBackground(p: Promise<unknown>): void;

package/dist/background.js

@@ -0,0 +1,17 @@
+/**
+ * Global background task holder for Cloudflare Workers.
+ * Worker sets ctx.waitUntil via setWaitUntil() at request start,
+ * then any module can call runBackground() to keep promises alive
+ * after the Response is sent.
+ */
+let _waitUntil = null;
+export function setWaitUntil(fn) {
+    _waitUntil = fn;
+}
+export function runBackground(p) {
+    if (_waitUntil) {
+        _waitUntil(p);
+    }
+    // Always attach error handler to prevent unhandled rejection
+    p.then(() => { }, (err) => console.error("[bg]", err.message));
+}

package/dist/config.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Plan limits config for MCP server.
+ * Mirrors trace-web/src/config/plans.ts — keep in sync.
+ *
+ * TODO: When Stripe is integrated, fetch plan from DB per user.
+ * For now, all users get free plan limits.
+ */
+export interface PlanLimits {
+    traces: number;
+    tokens: number;
+    rateLimit: number;
+    maxExtractPerSummary: number;
+    auditLogDays: number;
+    conflictAutoSupersede: boolean;
+}
+export declare const PLAN_LIMITS: {
+    readonly free: {
+        readonly traces: 100;
+        readonly tokens: 5;
+        readonly rateLimit: 20;
+        readonly maxExtractPerSummary: 20;
+        readonly auditLogDays: 7;
+        readonly conflictAutoSupersede: false;
+    };
+    readonly pro: {
+        readonly traces: 1000;
+        readonly tokens: 10;
+        readonly rateLimit: 60;
+        readonly maxExtractPerSummary: 20;
+        readonly auditLogDays: 7;
+        readonly conflictAutoSupersede: false;
+    };
+    readonly team: {
+        readonly traces: 5000;
+        readonly tokens: 20;
+        readonly rateLimit: 120;
+        readonly maxExtractPerSummary: 20;
+        readonly auditLogDays: 365;
+        readonly conflictAutoSupersede: true;
+    };
+};
+/**
+ * Get limits for a user. Currently returns free plan for all users.
+ * When Stripe is integrated, this will look up the user's subscription.
+ */
+export declare function getUserLimits(_userId: string): PlanLimits;

package/dist/config.js

@@ -0,0 +1,20 @@
+/**
+ * Plan limits config for MCP server.
+ * Mirrors trace-web/src/config/plans.ts — keep in sync.
+ *
+ * TODO: When Stripe is integrated, fetch plan from DB per user.
+ * For now, all users get free plan limits.
+ */
+export const PLAN_LIMITS = {
+    free: { traces: 100, tokens: 5, rateLimit: 20, maxExtractPerSummary: 20, auditLogDays: 7, conflictAutoSupersede: false },
+    pro: { traces: 1000, tokens: 10, rateLimit: 60, maxExtractPerSummary: 20, auditLogDays: 7, conflictAutoSupersede: false },
+    team: { traces: 5000, tokens: 20, rateLimit: 120, maxExtractPerSummary: 20, auditLogDays: 365, conflictAutoSupersede: true },
+};
+/**
+ * Get limits for a user. Currently returns free plan for all users.
+ * When Stripe is integrated, this will look up the user's subscription.
+ */
+export function getUserLimits(_userId) {
+    // TODO: look up user plan from DB
+    return PLAN_LIMITS.free;
+}

package/dist/conflict.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Conflict detection: find traces that contradict a newly created trace.
+ * Uses embedding similarity + LLM judgment.
+ */
+export interface ConflictResult {
+    existing_trace_id: string;
+    reason: string;
+    should_supersede: boolean;
+}
+export declare function detectConflicts(traceId: string, userId: string): Promise<ConflictResult[]>;
+/**
+ * Auto-supersede conflicting traces and return warnings.
+ */
+export declare function handleConflicts(traceId: string, userId: string): Promise<string[]>;

package/dist/conflict.js

@@ -0,0 +1,103 @@
+/**
+ * Conflict detection: find traces that contradict a newly created trace.
+ * Uses embedding similarity + LLM judgment.
+ */
+import { getSupabase } from "./supabase.js";
+import { llmChat } from "./llm.js";
+import { getUserLimits } from "./config.js";
+const CONFLICT_PROMPT = `You are a knowledge conflict detector. Given a NEW trace and a list of EXISTING traces, determine if the new trace contradicts any existing ones.
+
+A contradiction means the new trace says the OPPOSITE of an existing trace about the SAME topic. Examples:
+- New: "Use Vite for bundling" vs Existing: "Use Webpack for bundling" → CONFLICT
+- New: "API uses REST" vs Existing: "API uses GraphQL" → CONFLICT
+- New: "Added pagination" vs Existing: "Added search" → NOT a conflict (different topics)
+- New: "Password min 8 chars" vs Existing: "Password min 6 chars" → CONFLICT (supersedes)
+
+Return JSON:
+{
+  "conflicts": [
+    {
+      "existing_trace_id": "uuid",
+      "reason": "Why this is a contradiction (one sentence)",
+      "should_supersede": true
+    }
+  ]
+}
+
+If no conflicts, return: { "conflicts": [] }
+Be conservative — only flag clear contradictions, not mere differences.`;
+export async function detectConflicts(traceId, userId) {
+    const supabase = getSupabase();
+    // 1. Get the new trace
+    const { data: trace } = await supabase
+        .from("traces")
+        .select("id, claim, reason, content, context, tags, embedding")
+        .eq("id", traceId)
+        .single();
+    if (!trace?.embedding)
+        return [];
+    // 2. Find similar traces (potential conflicts)
+    const { data: similar } = await supabase.rpc("search_traces", {
+        query_embedding: trace.embedding,
+        match_limit: 10,
+        match_threshold: 0.5,
+        filter_status: "active",
+        filter_tags: [],
+    });
+    // Filter to same author, exclude self
+    const candidates = (similar ?? [])
+        .filter((r) => r.author === userId && r.id !== traceId);
+    if (candidates.length === 0)
+        return [];
+    // 3. LLM judgment
+    const userMessage = JSON.stringify({
+        new_trace: {
+            id: trace.id,
+            claim: trace.content || trace.claim,
+            reason: trace.context || trace.reason,
+        },
+        existing_traces: candidates.slice(0, 5).map((t) => ({
+            id: t.id,
+            claim: t.claim,
+            reason: t.reason,
+            tags: t.tags,
+        })),
+    }, null, 2);
+    const content = await llmChat([
+        { role: "system", content: CONFLICT_PROMPT },
+        { role: "user", content: userMessage },
+    ]);
+    try {
+        const result = JSON.parse(content);
+        return result.conflicts ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Auto-supersede conflicting traces and return warnings.
+ */
+export async function handleConflicts(traceId, userId) {
+    const conflicts = await detectConflicts(traceId, userId);
+    if (conflicts.length === 0)
+        return [];
+    const limits = getUserLimits(userId);
+    const supabase = getSupabase();
+    const warnings = [];
+    for (const conflict of conflicts) {
+        if (conflict.should_supersede && limits.conflictAutoSupersede) {
+            // Mark old trace as superseded (Team plan only)
+            await supabase
+                .from("traces")
+                .update({ status: "superseded" })
+                .eq("id", conflict.existing_trace_id)
+                .eq("author", userId);
+            warnings.push(`⚠ Superseded trace ${conflict.existing_trace_id}: ${conflict.reason}`);
+        }
+        else {
+            warnings.push(`⚠ Potential conflict with ${conflict.existing_trace_id}: ${conflict.reason}`);
+        }
+    }
+    return warnings;
+}

package/dist/embedding.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Embedding generation — supports Ollama (local) and OpenAI (cloud)
+ * Set OPENAI_API_KEY to use OpenAI, otherwise falls back to Ollama
+ */
+export declare function generateEmbedding(text: string): Promise<number[]>;
+export declare function generateEmbeddings(texts: string[]): Promise<number[][]>;

package/dist/embedding.js

@@ -0,0 +1,74 @@
+/**
+ * Embedding generation — supports Ollama (local) and OpenAI (cloud)
+ * Set OPENAI_API_KEY to use OpenAI, otherwise falls back to Ollama
+ */
+function getOllamaUrl() {
+    return process.env.OLLAMA_URL ?? "http://localhost:11434";
+}
+const OLLAMA_EMBED_MODEL = "nomic-embed-text";
+function getOpenAIKey() {
+    return process.env.OPENAI_API_KEY;
+}
+function getOpenAIEmbedModel() {
+    return process.env.OPENAI_EMBED_MODEL ?? "text-embedding-3-small";
+}
+async function ollamaEmbedding(text) {
+    const response = await fetch(`${getOllamaUrl()}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model: OLLAMA_EMBED_MODEL, input: text }),
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama embedding failed (${response.status}): ${await response.text()}. ` +
+            `請確認 Ollama 正在運行且已安裝 ${OLLAMA_EMBED_MODEL} 模型。`);
+    }
+    const data = await response.json();
+    return data.embeddings[0];
+}
+async function openaiEmbedding(text) {
+    const response = await fetch("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${getOpenAIKey()}`,
+        },
+        body: JSON.stringify({
+            model: getOpenAIEmbedModel(),
+            input: text,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`OpenAI embedding failed (${response.status}): ${await response.text()}`);
+    }
+    const data = await response.json();
+    return data.data[0].embedding;
+}
+export async function generateEmbedding(text) {
+    if (getOpenAIKey()) {
+        return openaiEmbedding(text);
+    }
+    return ollamaEmbedding(text);
+}
+async function openaiEmbeddingBatch(texts) {
+    const response = await fetch("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${getOpenAIKey()}`,
+        },
+        body: JSON.stringify({ model: getOpenAIEmbedModel(), input: texts }),
+    });
+    if (!response.ok) {
+        throw new Error(`OpenAI embedding batch failed (${response.status}): ${await response.text()}`);
+    }
+    const data = await response.json();
+    return data.data.sort((a, b) => a.index - b.index).map(d => d.embedding);
+}
+export async function generateEmbeddings(texts) {
+    if (texts.length === 0)
+        return [];
+    if (getOpenAIKey()) {
+        return openaiEmbeddingBatch(texts);
+    }
+    return Promise.all(texts.map(t => ollamaEmbedding(t)));
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,104 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { registerCreate } from "./tools/create.js";
+import { registerSearch } from "./tools/search.js";
+import { registerChain } from "./tools/chain.js";
+import { registerActive } from "./tools/active.js";
+import { registerUpdate } from "./tools/update.js";
+import { registerExtract } from "./tools/extract.js";
+import { registerContext } from "./tools/context.js";
+import { registerSummary } from "./tools/summary.js";
+import { randomUUID, createHash } from "node:crypto";
+import { getSupabase } from "./supabase.js";
+async function resolveUserIdFromToken() {
+    const token = process.env.TRAPIC_TOKEN;
+    if (!token?.startsWith("tr_"))
+        return null;
+    const tokenHash = createHash("sha256").update(token).digest("hex");
+    const supabase = getSupabase();
+    const { data } = await supabase
+        .from("trace_api_tokens")
+        .select("user_id")
+        .eq("token_hash", tokenHash)
+        .is("revoked_at", null)
+        .single();
+    return data?.user_id ?? null;
+}
+const userId = await resolveUserIdFromToken();
+const server = new McpServer({
+    name: "trapic-mcp",
+    version: "0.1.0",
+});
+// Register all tools
+registerCreate(server, userId);
+registerSearch(server, userId);
+registerChain(server, userId); // trace.get_chain + trace.get_effects
+registerActive(server, userId);
+registerUpdate(server, userId);
+registerExtract(server);
+registerContext(server, userId); // trace.contextualize + trace.get_context + trace.find_contexts
+registerSummary(server, userId);
+const isHttpMode = process.env.TRANSPORT === "http" || process.argv.includes("--http");
+if (isHttpMode) {
+    const app = createMcpExpressApp({ host: "0.0.0.0" });
+    const transports = new Map();
+    app.post("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        let transport;
+        if (sessionId && transports.has(sessionId)) {
+            transport = transports.get(sessionId);
+        }
+        else {
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+            });
+            transport.onclose = () => {
+                const sid = transport.sessionId;
+                if (sid)
+                    transports.delete(sid);
+            };
+            await server.connect(transport);
+            // Capture session ID after response is sent
+            res.on("finish", () => {
+                const sid = res.getHeader("mcp-session-id");
+                if (sid && !transports.has(sid)) {
+                    transports.set(sid, transport);
+                }
+            });
+        }
+        await transport.handleRequest(req, res, req.body);
+    });
+    app.get("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports.has(sessionId)) {
+            res.status(400).json({ error: "Missing or invalid session ID" });
+            return;
+        }
+        const transport = transports.get(sessionId);
+        await transport.handleRequest(req, res);
+    });
+    app.delete("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (sessionId && transports.has(sessionId)) {
+            const transport = transports.get(sessionId);
+            await transport.close();
+            transports.delete(sessionId);
+        }
+        res.status(200).end();
+    });
+    // Health check
+    app.get("/health", (_req, res) => {
+        res.json({ status: "ok", server: "trapic-mcp", version: "0.1.0" });
+    });
+    const port = parseInt(process.env.PORT || "3100", 10);
+    app.listen(port, "0.0.0.0", () => {
+        console.log(`trapic-mcp HTTP server running on http://0.0.0.0:${port}/mcp`);
+    });
+}
+else {
+    // Default: stdio transport (local usage)
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/llm.d.ts

@@ -0,0 +1,10 @@
+/**
+ * LLM chat completion — Groq (primary) → OpenAI (fallback)
+ * Both use OpenAI-compatible API format
+ */
+interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export declare function llmChat(messages: ChatMessage[]): Promise<string>;
+export {};

package/dist/llm.js

@@ -0,0 +1,47 @@
+/**
+ * LLM chat completion — Groq (primary) → OpenAI (fallback)
+ * Both use OpenAI-compatible API format
+ */
+function getGroqKey() {
+    return process.env.GROQ_API_KEY;
+}
+function getGroqModel() {
+    return process.env.GROQ_CHAT_MODEL ?? "llama-3.1-8b-instant";
+}
+function getOpenAIKey() {
+    return process.env.OPENAI_API_KEY;
+}
+function getOpenAIModel() {
+    return process.env.OPENAI_CHAT_MODEL ?? "gpt-4o-mini";
+}
+async function chatCompletion(baseUrl, apiKey, model, messages) {
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            model,
+            messages,
+            temperature: 0.2,
+            response_format: { type: "json_object" },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`LLM chat failed (${response.status}): ${await response.text()}`);
+    }
+    const data = (await response.json());
+    return data.choices[0].message.content;
+}
+export async function llmChat(messages) {
+    const groqKey = getGroqKey();
+    if (groqKey) {
+        return chatCompletion("https://api.groq.com/openai/v1", groqKey, getGroqModel(), messages);
+    }
+    const openaiKey = getOpenAIKey();
+    if (openaiKey) {
+        return chatCompletion("https://api.openai.com/v1", openaiKey, getOpenAIModel(), messages);
+    }
+    throw new Error("No LLM API key configured. Set GROQ_API_KEY or OPENAI_API_KEY.");
+}

package/dist/ollama.d.ts

@@ -0,0 +1,11 @@
+/**
+ * LLM chat completion — supports Ollama (local) and OpenAI (cloud)
+ * Set OPENAI_API_KEY to use OpenAI, otherwise falls back to Ollama
+ */
+interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export declare function ollamaChat(messages: ChatMessage[]): Promise<string>;
+export {};
+//# sourceMappingURL=ollama.d.ts.map