@muxoai/sdk 1.3.0 → 1.4.3

package/dist/memory-graph.d.ts

@@ -0,0 +1,45 @@
+import type { ConnectionRecord, GovernancePolicy, MemoryGraphEdge, MemoryGraphNode, MemoryKnowledgeGraph, ProvisionedResource, TemporalGraphFact } from "./types.js";
+export interface MemoryGraphInput {
+    workspace: {
+        id: string;
+        slug: string;
+        name: string;
+        tier: string;
+        policy?: GovernancePolicy;
+    };
+    namespace: string;
+    query?: string;
+    asOf?: string | null;
+    focalEntity?: string | null;
+    maxHops?: number;
+    facts: TemporalGraphFact[];
+    resources: Array<Pick<ProvisionedResource, "resourceName" | "status" | "providerName" | "serviceSlug">>;
+    activeConnections: Array<Pick<ConnectionRecord, "id" | "providerSlug" | "providerName" | "createdAt">>;
+    memoriesCount: number;
+}
+/**
+ * Graphiti-style Point-in-Time ("As-Of") Bi-Temporal Fact Filter.
+ * Reconstructs which facts were active at `asOf` vs. already retired by `asOf`,
+ * excluding facts created after `asOf`.
+ */
+export declare function filterFactsAsOf(facts: TemporalGraphFact[], asOf?: string | null): {
+    scopedFacts: TemporalGraphFact[];
+    isActiveAtPointInTime: (fact: TemporalGraphFact) => boolean;
+};
+/**
+ * Graphiti-style Multi-Hop Subgraph Community Traversal (BFS).
+ * Finds all nodes and edges within `maxHops` (default 2) of a focal entity.
+ */
+export declare function traverseSubgraphBfs(nodes: MemoryGraphNode[], edges: MemoryGraphEdge[], focalQuery: string, maxHops?: number): {
+    focalEntity: string;
+    maxHops: number;
+    nodes: MemoryGraphNode[];
+    edges: MemoryGraphEdge[];
+    hopDistances: Record<string, number>;
+};
+/**
+ * Builds the Graphiti-inspired Bi-Temporal Knowledge Graph (nodes, active/historical edges,
+ * episodic provenance, point-in-time `asOf` time-travel, 2-hop BFS subgraph, and Mermaid preview)
+ * from runtime-agnostic inputs so the Node engine and the Edge Worker render identical graphs.
+ */
+export declare function buildMemoryKnowledgeGraph(input: MemoryGraphInput): MemoryKnowledgeGraph;

package/dist/memory-graph.js

@@ -0,0 +1,293 @@
+import { formatHumanFriendlyExplanation } from "./policy.js";
+/**
+ * Graphiti-style Point-in-Time ("As-Of") Bi-Temporal Fact Filter.
+ * Reconstructs which facts were active at `asOf` vs. already retired by `asOf`,
+ * excluding facts created after `asOf`.
+ */
+export function filterFactsAsOf(facts, asOf) {
+    if (!asOf || !asOf.trim()) {
+        return {
+            scopedFacts: facts,
+            isActiveAtPointInTime: (fact) => fact.validTo === null,
+        };
+    }
+    const asOfMs = Date.parse(asOf);
+    if (!Number.isFinite(asOfMs)) {
+        return {
+            scopedFacts: facts,
+            isActiveAtPointInTime: (fact) => fact.validTo === null,
+        };
+    }
+    const scopedFacts = facts.filter((fact) => {
+        const validFromMs = Date.parse(fact.validFrom || fact.createdAt);
+        return !Number.isFinite(validFromMs) || validFromMs <= asOfMs;
+    });
+    return {
+        scopedFacts,
+        isActiveAtPointInTime: (fact) => {
+            if (!fact.validTo)
+                return true;
+            const validToMs = Date.parse(fact.validTo);
+            return Number.isFinite(validToMs) && validToMs > asOfMs;
+        },
+    };
+}
+/**
+ * Graphiti-style Multi-Hop Subgraph Community Traversal (BFS).
+ * Finds all nodes and edges within `maxHops` (default 2) of a focal entity.
+ */
+export function traverseSubgraphBfs(nodes, edges, focalQuery, maxHops = 2) {
+    const needle = focalQuery.trim().toLowerCase();
+    const clampedHops = Math.min(4, Math.max(1, Number(maxHops) || 2));
+    const seedNode = nodes.find((n) => n.id.toLowerCase() === needle) ||
+        nodes.find((n) => n.label.toLowerCase() === needle) ||
+        nodes.find((n) => n.id.toLowerCase().includes(needle) ||
+            n.label.toLowerCase().includes(needle)) ||
+        nodes[0];
+    if (!seedNode) {
+        return {
+            focalEntity: focalQuery,
+            maxHops: clampedHops,
+            nodes: [],
+            edges: [],
+            hopDistances: {},
+        };
+    }
+    const hopDistances = { [seedNode.id]: 0 };
+    const queue = [
+        { nodeId: seedNode.id, depth: 0 },
+    ];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current.depth >= clampedHops)
+            continue;
+        for (const edge of edges) {
+            let neighborId = null;
+            if (edge.source === current.nodeId)
+                neighborId = edge.target;
+            else if (edge.target === current.nodeId)
+                neighborId = edge.source;
+            if (neighborId && hopDistances[neighborId] === undefined) {
+                hopDistances[neighborId] = current.depth + 1;
+                queue.push({ nodeId: neighborId, depth: current.depth + 1 });
+            }
+        }
+    }
+    const subNodes = nodes
+        .filter((n) => hopDistances[n.id] !== undefined)
+        .map((n) => ({ ...n, hopDistance: hopDistances[n.id] }));
+    const subEdges = edges.filter((e) => hopDistances[e.source] !== undefined &&
+        hopDistances[e.target] !== undefined);
+    return {
+        focalEntity: seedNode.id,
+        maxHops: clampedHops,
+        nodes: subNodes,
+        edges: subEdges,
+        hopDistances,
+    };
+}
+/**
+ * Builds the Graphiti-inspired Bi-Temporal Knowledge Graph (nodes, active/historical edges,
+ * episodic provenance, point-in-time `asOf` time-travel, 2-hop BFS subgraph, and Mermaid preview)
+ * from runtime-agnostic inputs so the Node engine and the Edge Worker render identical graphs.
+ */
+export function buildMemoryKnowledgeGraph(input) {
+    const ws = input.workspace;
+    const query = input.query;
+    const asOf = input.asOf ?? null;
+    const maxHops = Math.min(4, Math.max(1, Number(input.maxHops || 2)));
+    const { scopedFacts, isActiveAtPointInTime } = filterFactsAsOf(input.facts, asOf);
+    const nodeMap = new Map();
+    const rootId = `workspace:${ws.slug}`;
+    nodeMap.set(rootId, {
+        id: rootId,
+        kind: "workspace",
+        label: ws.name,
+        summary: `Workspace ${ws.name} (${ws.slug}, tier=${ws.tier})`,
+        status: "active",
+        metadata: { workspaceId: ws.id, tier: ws.tier },
+    });
+    const ensureNode = (id, status, fallbackKind = "entity", summary) => {
+        const existing = nodeMap.get(id);
+        if (existing) {
+            if (status === "active" && existing.status === "historical") {
+                existing.status = "active";
+            }
+            return existing;
+        }
+        const kind = id.startsWith("workspace:")
+            ? "workspace"
+            : id.startsWith("resource:")
+                ? "resource"
+                : id.startsWith("connection:")
+                    ? "connection"
+                    : id.startsWith("tool:")
+                        ? "tool"
+                        : id.startsWith("guardrail:")
+                            ? "guardrail"
+                            : id.startsWith("episode:")
+                                ? "episode"
+                                : fallbackKind;
+        const label = id.includes(":")
+            ? id.split(":").slice(1).join(":")
+            : id.length > 36
+                ? `${id.slice(0, 33)}...`
+                : id;
+        const created = {
+            id,
+            kind,
+            label,
+            summary: summary || label,
+            status,
+        };
+        nodeMap.set(id, created);
+        return created;
+    };
+    let episodesCount = 0;
+    const edges = scopedFacts.map((fact) => {
+        const status = isActiveAtPointInTime(fact)
+            ? "active"
+            : "historical";
+        const objKind = fact.sourceKind === "preference"
+            ? "preference"
+            : fact.sourceKind === "policy_decision"
+                ? "guardrail"
+                : fact.sourceKind === "resource_topology"
+                    ? "resource"
+                    : "entity";
+        ensureNode(fact.subject, status, "entity", fact.subject);
+        ensureNode(fact.object, status, objKind, fact.summary);
+        const episodeId = fact.episodeId || fact.sourceReferenceId || null;
+        if (episodeId) {
+            const epNodeId = episodeId.startsWith("episode:")
+                ? episodeId
+                : `episode:${episodeId}`;
+            if (!nodeMap.has(epNodeId))
+                episodesCount += 1;
+            ensureNode(epNodeId, status, "episode", `Episodic provenance (${episodeId})`);
+        }
+        return {
+            id: fact.id,
+            source: fact.subject,
+            target: fact.object,
+            subject: fact.subject,
+            object: fact.object,
+            predicate: fact.predicate,
+            summary: fact.summary,
+            confidence: fact.confidence,
+            status,
+            validFrom: fact.validFrom,
+            validTo: status === "active" && asOf ? null : fact.validTo,
+            transactionFrom: fact.transactionFrom || fact.createdAt,
+            transactionTo: fact.transactionTo ?? fact.validTo,
+            episodeId,
+            supersededById: fact.supersededById ?? null,
+            sourceKind: fact.sourceKind,
+            sourceReferenceId: fact.sourceReferenceId ?? null,
+        };
+    });
+    for (const res of input.resources) {
+        ensureNode(`resource:${res.resourceName}`, res.status === "active" ? "active" : "historical", "resource", `${res.resourceName} (${res.providerName} / ${res.serviceSlug})`);
+    }
+    for (const conn of input.activeConnections) {
+        const connId = `connection:${conn.providerSlug}`;
+        ensureNode(connId, "active", "connection", `Connected OAuth App: ${conn.providerName} (${conn.providerSlug})`);
+        if (!edges.some((e) => e.source === rootId && e.target === connId)) {
+            edges.push({
+                id: `edge_conn_${conn.id}`,
+                source: rootId,
+                target: connId,
+                predicate: "CONNECTED_TO",
+                summary: `${ws.name} has active OAuth connection to ${conn.providerName}`,
+                confidence: 1.0,
+                status: "active",
+                validFrom: conn.createdAt,
+                validTo: null,
+                transactionFrom: conn.createdAt,
+                transactionTo: null,
+                episodeId: conn.id,
+                supersededById: null,
+                sourceKind: "system",
+                sourceReferenceId: conn.id,
+            });
+        }
+    }
+    const activeEdges = edges.filter((e) => e.status === "active");
+    const historicalEdges = edges.filter((e) => e.status === "historical");
+    const nodes = Array.from(nodeMap.values());
+    const focalTarget = input.focalEntity || query || null;
+    const subgraph = focalTarget
+        ? traverseSubgraphBfs(nodes, edges, focalTarget, maxHops)
+        : null;
+    const safeMermaidId = (raw, idx) => `N${idx}_${raw.replace(/[^a-zA-Z0-9]/g, "_").slice(0, 14)}`;
+    const nodeIndex = new Map();
+    nodes.slice(0, 24).forEach((n, idx) => {
+        nodeIndex.set(n.id, safeMermaidId(n.label, idx));
+    });
+    const mermaidLines = ["flowchart LR"];
+    for (const n of nodes.slice(0, 24)) {
+        const mId = nodeIndex.get(n.id);
+        const cleanLabel = n.label.replace(/"/g, "'").slice(0, 22);
+        mermaidLines.push(`  ${mId}["${cleanLabel}"]`);
+    }
+    for (const e of edges.slice(0, 24)) {
+        const srcId = nodeIndex.get(e.source);
+        const tgtId = nodeIndex.get(e.target);
+        if (!srcId || !tgtId)
+            continue;
+        const pred = e.predicate.replace(/"/g, "'").slice(0, 18);
+        if (e.status === "active") {
+            mermaidLines.push(`  ${srcId} -->|${pred}| ${tgtId}`);
+        }
+        else {
+            mermaidLines.push(`  ${srcId} -.->|RETIRED: ${pred}| ${tgtId}`);
+        }
+    }
+    const headline = `Bi-Temporal Knowledge Graph (${ws.name}${asOf ? ` as of ${asOf}` : ""}): ${activeEdges.length} active relationship${activeEdges.length === 1 ? "" : "s"}, ${historicalEdges.length} superseded historical relationship${historicalEdges.length === 1 ? "" : "s"} across ${nodes.length} node${nodes.length === 1 ? "" : "s"}.`;
+    const activePreview = activeEdges
+        .slice(0, 4)
+        .map((e) => `${e.source} --[${e.predicate}]--> ${e.target}`)
+        .join("; ");
+    const nonTechnical = [
+        headline,
+        activeEdges.length > 0
+            ? `Current facts: ${activeEdges.slice(0, 3).map((e) => e.summary).join(" · ")}.`
+            : "No active facts recorded yet.",
+        historicalEdges.length > 0
+            ? `Time-travel lineage: ${historicalEdges.length} older fact${historicalEdges.length === 1 ? " was" : "s were"} automatically retired when newer workspace settings or facts replaced them.`
+            : "No superseded historical facts yet.",
+    ].join(" ");
+    const technical = `workspace=${ws.id} | namespace=${input.namespace} | asOf=${asOf || "latest"} | nodes=${nodes.length} | activeEdges=${activeEdges.length} | historicalEdges=${historicalEdges.length} | episodes=${episodesCount} | memories=${input.memoriesCount} | activePreview=[${activePreview || "none"}]`;
+    const explanation = formatHumanFriendlyExplanation({
+        headline,
+        nonTechnical,
+        technical,
+        policy: ws.policy,
+    });
+    return {
+        workspaceId: ws.id,
+        workspaceSlug: ws.slug,
+        namespace: input.namespace,
+        generatedAt: new Date().toISOString(),
+        asOf,
+        focalEntity: subgraph?.focalEntity ?? null,
+        maxHops,
+        query: query ?? null,
+        nodes,
+        edges,
+        activeEdges,
+        historicalEdges,
+        subgraph,
+        stats: {
+            nodesCount: nodes.length,
+            activeEdgesCount: activeEdges.length,
+            historicalEdgesCount: historicalEdges.length,
+            memoriesCount: input.memoriesCount,
+            resourcesCount: input.resources.length,
+            connectionsCount: input.activeConnections.length,
+            episodesCount,
+        },
+        mermaid: mermaidLines.join("\n"),
+        explanation,
+    };
+}

package/dist/nl.js

@@ -80,23 +80,39 @@ export function extractParametersFromNaturalLanguage(prompt, tool, explicitInput
             input.numResults = extractNumberAfterKeyword(text, ["results", "limit", "top"], 5);
         }
     }
-    else if (slug === "instant.code.execute") {
-        if (!input.language) {
+    else if (slug === "instant.code.execute" || slug === "instant.composio.workbench") {
+        if (!input.language && slug === "instant.code.execute") {
             input.language = /\b(javascript|js|node|typescript|ts)\b/i.test(text)
                 ? "javascript"
                 : "python";
         }
-        if (!input.code) {
-            const codeBlock = text.match(/```(?:\w+)?\n([\s\S]*?)```/);
-            if (codeBlock) {
-                input.code = codeBlock[1].trim();
+        const codeBlock = text.match(/```(?:\w+)?\n([\s\S]*?)```/);
+        const inlineCode = text.match(/`([^`]+)`/);
+        const extractedCode = codeBlock
+            ? codeBlock[1].trim()
+            : inlineCode
+                ? inlineCode[1].trim()
+                : text;
+        if (slug === "instant.composio.workbench") {
+            if (!input.code_to_execute) {
+                input.code_to_execute = String(input.code || extractedCode);
             }
-            else {
-                const inlineCode = text.match(/`([^`]+)`/);
-                if (inlineCode)
-                    input.code = inlineCode[1].trim();
+            if (!input.thought) {
+                input.thought = `Natural language workbench execution: ${text.slice(0, 80)}`;
             }
         }
+        else if (!input.code) {
+            input.code = extractedCode;
+        }
+    }
+    else if (slug === "instant.github.repo_intel") {
+        const repoMatch = text.match(/\b([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)\b/);
+        if (repoMatch && !repoMatch[0].includes(".ai") && !repoMatch[0].includes(".com")) {
+            if (!input.owner)
+                input.owner = repoMatch[1];
+            if (!input.repo)
+                input.repo = repoMatch[2];
+        }
     }
     else if (slug.startsWith("resource.")) {
         if (!input.resource_name && !input.name) {
@@ -207,6 +223,93 @@ export function extractParametersFromNaturalLanguage(prompt, tool, explicitInput
             input.limit = extractNumberAfterKeyword(text, ["top", "stories", "items", "limit", "posts"], 5);
         }
     }
+    else if (slug === "app.jira.create_issue") {
+        if (!input.project_key) {
+            const projMatch = text.match(/\bproject\s+([A-Z][A-Z0-9]{1,9})\b|\b([A-Z]{2,8})-\d+\b/);
+            input.project_key = projMatch ? projMatch[1] || projMatch[2] : "ENG";
+        }
+        if (!input.summary) {
+            const sumMatch = text.match(/\b(?:summary|titled|title)\s*[:=]?\s*["']?([^"'\n]+)["']?/i);
+            input.summary = sumMatch ? sumMatch[1].trim() : text.slice(0, 80);
+        }
+        if (!input.issue_type)
+            input.issue_type = "Task";
+    }
+    else if (slug === "app.linear.create_issue") {
+        if (!input.team_id) {
+            const teamMatch = text.match(/\bteam\s+["']?([a-zA-Z0-9_-]+)["']?/i);
+            input.team_id = teamMatch ? teamMatch[1] : "ENG";
+        }
+        if (!input.title) {
+            const titleMatch = text.match(/\b(?:titled|title)\s*[:=]?\s*["']?([^"'\n]+)["']?/i);
+            input.title = titleMatch ? titleMatch[1].trim() : text.slice(0, 80);
+        }
+    }
+    else if (slug === "app.googlecalendar.list_events") {
+        if (!input.calendarId)
+            input.calendarId = "primary";
+        if (input.maxResults === undefined) {
+            input.maxResults = extractNumberAfterKeyword(text, ["events", "meetings", "limit", "next"], 10);
+        }
+    }
+    else if (slug === "app.hubspot.search_contacts") {
+        if (!input.query) {
+            const cleaned = text.replace(/^(?:search\s+hubspot\s+(?:contacts\s+)?(?:for)?|find\s+contact)\s*/i, "").trim();
+            input.query = cleaned || text;
+        }
+        if (input.limit === undefined)
+            input.limit = 10;
+    }
+    else if (slug === "app.discord.send_message") {
+        if (!input.channel_id) {
+            const chMatch = text.match(/#([a-zA-Z0-9_-]+)|\bchannel\s+([a-zA-Z0-9_-]+)/i);
+            input.channel_id = chMatch ? chMatch[1] || chMatch[2] : "general";
+        }
+        if (!input.content) {
+            const msgMatch = text.match(/\b(?:saying|message|text|content)\s*[:=]?\s*["']?([\s\S]+?)["']?$/i);
+            input.content = msgMatch ? msgMatch[1].trim() : text;
+        }
+    }
+    else if (slug === "app.googledrive.search_files") {
+        if (!input.query) {
+            const cleaned = text.replace(/^(?:search\s+(?:google\s+)?drive\s+(?:files\s+)?(?:for)?)\s*/i, "").trim();
+            input.query = cleaned || text;
+        }
+    }
+    else if (slug === "app.airtable.list_records") {
+        if (!input.base_id) {
+            const baseMatch = text.match(/\b(app[a-zA-Z0-9]{10,})\b/);
+            input.base_id = baseMatch ? baseMatch[1] : "appDefaultBase";
+        }
+        if (!input.table_name) {
+            const tblMatch = text.match(/\btable\s+["']?([a-zA-Z0-9_-]+)["']?/i);
+            input.table_name = tblMatch ? tblMatch[1] : "Tasks";
+        }
+    }
+    else if (slug === "app.salesforce.query_records" || slug === "app.salesforce.soql_query") {
+        if (!input.query) {
+            const soqlMatch = text.match(/\b(SELECT\s+[\s\S]+)$/i);
+            input.query = soqlMatch ? soqlMatch[1].trim() : "SELECT Id, Name, Email FROM Contact LIMIT 10";
+        }
+    }
+    else if (slug === "app.pagerduty.create_incident") {
+        if (!input.title)
+            input.title = text.slice(0, 80);
+        if (!input.service_id)
+            input.service_id = "PDEFAULT";
+    }
+    else if (slug === "billing.stripe.refund") {
+        if (!input.paymentIntentId) {
+            const piMatch = text.match(/\b(pi_[a-zA-Z0-9_]+|ch_[a-zA-Z0-9_]+)\b/);
+            if (piMatch)
+                input.paymentIntentId = piMatch[1];
+        }
+        if (input.amountCents === undefined) {
+            const dollarMatch = text.match(/\$(\d+(?:\.\d{1,2})?)/);
+            if (dollarMatch)
+                input.amountCents = Math.round(parseFloat(dollarMatch[1]) * 100);
+        }
+    }
     const schemaReq = Array.isArray(tool.inputSchema?.required)
         ? tool.inputSchema.required
         : [];
@@ -235,13 +338,19 @@ function scoreToolForPrompt(prompt, tool) {
         if (slug === "instant.web.scrape")
             score += 110;
     }
-    if (/\b(search\s+the\s+web|web\s+search|search\s+for|look\s+up|find\s+news|exa|google)\b/i.test(q)) {
+    const isExplicitWebSearch = /\b(search\s+(?:the\s+)?web|web\s+search|search\s+online|search\s+(?:for|about)|look\s+up|find\s+(?:news|info|information|articles)|exa|google)\b/i.test(q);
+    const hasProvisionVerb = /\b(provision|create|deploy|spin\s+up|setup|set\s+up|add\s+resource|new\s+db|new\s+database|database|db)\b/i.test(q);
+    if (isExplicitWebSearch) {
         if (slug === "instant.web.search")
-            score += 105;
+            score += 155;
     }
-    if (/\b(run\s+python|execute\s+code|run\s+script|sandbox|calculate|e2b)\b/i.test(q)) {
-        if (slug === "instant.code.execute")
-            score += 105;
+    if (/\b(run\s+python|execute\s+code|run\s+script|sandbox|workbench|calculate|e2b)\b/i.test(q)) {
+        if (slug === "instant.code.execute" || slug === "instant.composio.workbench")
+            score += 125;
+    }
+    if (/\b(repo\s+intel|github\s+repo|inspect\s+repo|repository\s+intel|stars\s+and\s+forks)\b/i.test(q)) {
+        if (slug === "instant.github.repo_intel")
+            score += 135;
     }
     if (/\b(top\s*up|add\s+credits|buy\s+credits|refill\s+credits|more\s+credits|\d+\s+credits)\b/i.test(q)) {
         if (slug === "billing.credits.topup")
@@ -255,27 +364,53 @@ function scoreToolForPrompt(prompt, tool) {
         if (slug === "billing.checkout.create")
             score += 125;
     }
-    if (/\b(turso|libsql|sqlite\s+database|sqlite\s+db)\b/i.test(q)) {
-        if (slug.startsWith("resource.turso."))
-            score += 120;
-        if (slug.includes("database"))
-            score += 15;
-    }
-    if (/\b(neon|postgres|postgresql|pg\s+database)\b/i.test(q)) {
-        if (slug.startsWith("resource.neon."))
-            score += 120;
-    }
-    if (/\b(upstash|redis|cache\s+store|kv\s+store)\b/i.test(q)) {
-        if (slug.startsWith("resource.upstash."))
-            score += 120;
-    }
-    if (/\b(supabase)\b/i.test(q)) {
-        if (slug.startsWith("resource.supabase."))
-            score += 120;
+    if (/\b(refund|chargeback|pi_[a-z0-9_]+)\b/i.test(q)) {
+        if (slug === "billing.stripe.refund" || slug === "app.shopify.create_refund")
+            score += 130;
     }
-    if (/\b(mongodb|mongo)\b/i.test(q)) {
-        if (slug.startsWith("resource.mongodb."))
-            score += 120;
+    if (!isExplicitWebSearch || hasProvisionVerb) {
+        if (/\b(turso|libsql|sqlite\s+database|sqlite\s+db)\b/i.test(q)) {
+            if (slug.startsWith("resource.turso."))
+                score += 120;
+            if (slug.includes("database"))
+                score += 15;
+        }
+        if (/\b(neon|postgres|postgresql|pg\s+database)\b/i.test(q)) {
+            if (slug.startsWith("resource.neon."))
+                score += 120;
+        }
+        if (/\b(upstash|redis|cache\s+store|kv\s+store)\b/i.test(q)) {
+            if (slug.startsWith("resource.upstash."))
+                score += 120;
+        }
+        if (/\b(supabase)\b/i.test(q)) {
+            if (slug.startsWith("resource.supabase."))
+                score += 120;
+        }
+        if (/\b(mongodb|mongo)\b/i.test(q)) {
+            if (slug.startsWith("resource.mongodb."))
+                score += 120;
+        }
+        if (/\b(cloudflare\s+worker|d1\s+database|r2\s+storage)\b/i.test(q)) {
+            if (slug.startsWith("resource.cloudflare."))
+                score += 120;
+        }
+        if (/\b(vercel\s+project|deploy\s+vercel)\b/i.test(q)) {
+            if (slug.startsWith("resource.vercel."))
+                score += 120;
+        }
+        if (/\b(resend\s+email|transactional\s+email\s+api)\b/i.test(q)) {
+            if (slug.startsWith("resource.resend."))
+                score += 120;
+        }
+        if (/\b(clerk\s+auth)\b/i.test(q)) {
+            if (slug.startsWith("resource.clerk."))
+                score += 120;
+        }
+        if (/\b(workos|enterprise\s+sso|scim)\b/i.test(q)) {
+            if (slug.startsWith("resource.workos."))
+                score += 120;
+        }
     }
     if (/\b(hacker\s*news|hn\s+stories|top\s+stories)\b/i.test(q)) {
         if (slug === "instant.hackernews.top_stories")
@@ -305,6 +440,10 @@ function scoreToolForPrompt(prompt, tool) {
         if (slug === "app.github.list_pull_requests" || slug === "app.github.list_issues")
             score += 110;
     }
+    if (/\b(list\s+github\s+repos|github\s+repositories|my\s+repos)\b/i.test(q)) {
+        if (slug === "app.github.list_repos")
+            score += 120;
+    }
     if (/\b(notion\s+page|search\s+notion)\b/i.test(q)) {
         if (slug === "app.notion.search_pages")
             score += 115;
@@ -313,6 +452,46 @@ function scoreToolForPrompt(prompt, tool) {
         if (slug === "app.linear.create_issue")
             score += 115;
     }
+    if (/\b(jira\s+issue|create\s+jira|atlassian|jql)\b/i.test(q)) {
+        if (slug.startsWith("app.jira."))
+            score += 120;
+    }
+    if (/\b(hubspot|crm\s+contacts?|search\s+contacts?)\b/i.test(q)) {
+        if (slug.startsWith("app.hubspot."))
+            score += 120;
+    }
+    if (/\b(discord\s+message|send\s+discord|post\s+to\s+discord)\b/i.test(q)) {
+        if (slug.startsWith("app.discord."))
+            score += 120;
+    }
+    if (/\b(google\s+drive|gdrive|drive\s+files?)\b/i.test(q)) {
+        if (slug.startsWith("app.googledrive."))
+            score += 120;
+    }
+    if (/\b(airtable|base\s+records?)\b/i.test(q)) {
+        if (slug.startsWith("app.airtable."))
+            score += 120;
+    }
+    if (/\b(salesforce|soql|crm\s+records?)\b/i.test(q)) {
+        if (slug.startsWith("app.salesforce."))
+            score += 120;
+    }
+    if (/\b(zendesk|support\s+tickets?)\b/i.test(q)) {
+        if (slug.startsWith("app.zendesk."))
+            score += 120;
+    }
+    if (/\b(shopify|store\s+orders?)\b/i.test(q)) {
+        if (slug.startsWith("app.shopify."))
+            score += 120;
+    }
+    if (/\b(pagerduty|on-call|trigger\s+incident)\b/i.test(q)) {
+        if (slug.startsWith("app.pagerduty."))
+            score += 120;
+    }
+    if (/\b(sentry|error\s+issues?|stack\s+traces?)\b/i.test(q)) {
+        if (slug.startsWith("app.sentry."))
+            score += 120;
+    }
     if (/\b(google\s+calendar|schedule\s+meeting|list\s+events|calendar\s+events)\b/i.test(q)) {
         if (slug.includes("calendar") || slug.includes("gcal"))
             score += 110;

package/dist/oauth.d.ts

@@ -0,0 +1,32 @@
+/** Shared OAuth 2.1 (PKCE + consent) helpers for the Node server and the edge worker. */
+export declare const DEFAULT_OAUTH_SCOPE = "mcp:tools muxo:mcp muxo:read muxo:execute muxo:provision";
+export declare const PKCE_VERIFIER_PATTERN: RegExp;
+export declare const OAUTH_CODE_TTL_MS: number;
+/** API keys minted through OAuth do not expire; this is the advisory lifetime clients see. */
+export declare const OAUTH_ACCESS_TOKEN_TTL_SECONDS = 2592000;
+export declare const LOOPBACK_CLIENT_NAME = "An app on this computer";
+export interface AuthorizeRequest {
+    clientId: string;
+    clientName: string;
+    redirectUri: string;
+    state: string;
+    codeChallenge: string | null;
+    codeChallengeMethod: "S256" | "plain" | null;
+    scope: string;
+}
+export declare function base64UrlEncode(bytes: Uint8Array): string;
+export declare function pkceS256(verifier: string): Promise<string>;
+export declare function timingSafeEqualText(a: string, b: string): boolean;
+/** Checks a token-endpoint code_verifier against the challenge stored with the authorization code. */
+export declare function verifyPkce(verifier: string, challenge: string, method: "S256" | "plain" | null): Promise<"ok" | "missing" | "mismatch">;
+export declare function oauthClientName(redirect: URL, clientId: string): string;
+/** Name of the workspace API key minted for an OAuth connection, as listed in the console. */
+export declare function oauthConnectionKeyName(clientName: string): string;
+/** Origin shown on the consent screen; app-scheme redirects have no origin, so show the scheme. */
+export declare function oauthRedirectOrigin(redirectUri: string): string;
+export declare function parseAuthorizeRequest(params: URLSearchParams): AuthorizeRequest | {
+    error: string;
+};
+/** Parses a token-endpoint body (form or JSON) and HTTP Basic client credentials into one parameter set. */
+export declare function parseOAuthFormBody(rawBody: string, contentType: string, authorizationHeader: string): URLSearchParams;
+export declare function oauthSecretToken(prefix: string): string;