@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/runtime/harness/system/runtime-memory-manager.js

@@ -3,7 +3,8 @@ import { extractMessageText } from "../../../utils/message-content.js";
 import { createResolvedModel } from "../../adapter/model/model-providers.js";
 import { FileBackedStore } from "./store.js";
 import { compileModel } from "../../../workspace/resource-compilers.js";
-import { resolveRefId } from "../../../workspace/support/workspace-ref-utils.js";
+import { resolvePromptValue, resolveRefId } from "../../../workspace/support/workspace-ref-utils.js";
+import { renderRuntimeMemoryManagerPrompt, renderRuntimeMemoryMutationReconciliationPrompt } from "../../support/runtime-prompts.js";
 const FORMATION_EVENT_TYPES = new Set([
     "request.state.changed",
     "approval.resolved",
@@ -52,14 +53,15 @@ export function readRuntimeMemoryFormationConfig(runtimeMemory, workspaceRoot) {
         },
         manager: {
             enabled: asBoolean(manager?.enabled) ?? true,
-            strategy: asStrategy(manager?.strategy) ?? "rules",
+            strategy: asStrategy(manager?.strategy) ?? "model",
             modelRef: asNonEmptyString(manager?.modelRef),
+            prompt: resolvePromptValue(manager?.prompt, workspaceRoot),
             maxContextRecords: asPositiveInteger(manager?.maxContextRecords) ?? 12,
         },
         background: {
             enabled: asBoolean(background?.enabled) ?? true,
             maxMessagesPerRequest: asPositiveInteger(background?.maxMessagesPerRequest) ?? asPositiveInteger(ingestion?.maxMessagesPerRequest) ?? 40,
-            scopes: normalizeScopeList(asMemoryScopes(background?.scopes) ?? ["session"]),
+            scopes: normalizeScopeList(asMemoryScopes(background?.scopes) ?? ["user", "project", "workspace"]),
             stateStorePath: asNonEmptyString(background?.stateStorePath) ?? `knowledge/${workspaceBaseName}-memory-formation-state.json`,
             writeOnApprovalResolution: asBoolean(background?.writeOnApprovalResolution) ?? asBoolean(ingestion?.writeOnApprovalResolution) ?? true,
             writeOnRequestCompletion: asBoolean(background?.writeOnRequestCompletion) ?? asBoolean(ingestion?.writeOnRequestCompletion) ?? true,
@@ -91,29 +93,38 @@ function summarizeApprovals(approvals) {
 export function createBackgroundMemoryCandidates(input) {
     const latestUser = excerpt(input.messages.filter((message) => message.role === "user").at(-1));
     const latestAssistant = excerpt(input.messages.filter((message) => message.role === "assistant").at(-1));
-    const userContext = latestUser ?? "No durable user context captured.";
-    const assistantContext = latestAssistant ?? "No durable assistant response captured.";
+    const userContext = latestUser ?? "(none)";
+    const assistantContext = latestAssistant ?? "(none)";
     const approvals = summarizeApprovals(input.approvals);
     const summarySeed = latestUser ?? latestAssistant ?? `Run ${input.requestId}`;
     const baseSummary = summarySeed.length > 120 ? `${summarySeed.slice(0, 117)}...` : summarySeed;
     const sourceRefBase = `runtime://sessions/${input.session.sessionId}/requests/${input.requestId}/background-reflection`;
-    return input.scopes.map((scope) => ({
-        kind: "episodic",
-        scope,
-        sourceType: "runtime-reflection",
-        sourceRef: `${sourceRefBase}#${scope}`,
-        summary: `${baseSummary} (${scope})`,
-        content: [
-            `Run ${input.requestId} completed for session ${input.session.sessionId}.`,
-            `Trigger: ${input.trigger}.`,
-            `Latest user context: ${userContext}`,
-            `Latest assistant context: ${assistantContext}`,
-            `Approvals: ${approvals}`,
-        ].join("\n"),
-        confidence: 0.72,
-        observedAt: input.recordedAt,
-        tags: ["background-reflection", "langmem-aligned", scope, input.trigger],
-    }));
+    return [{
+            kind: "episodic",
+            sourceType: "runtime-transcript",
+            sourceRef: sourceRefBase,
+            summary: baseSummary,
+            content: [
+                "Transcript evidence for durable knowledge extraction.",
+                `Trigger: ${input.trigger}`,
+                "",
+                "Latest user message:",
+                userContext,
+                "",
+                "Latest assistant response:",
+                assistantContext,
+                "",
+                "Approval snapshot:",
+                approvals,
+            ].join("\n"),
+            confidence: 0.72,
+            observedAt: input.recordedAt,
+            provenance: {
+                scopeOptions: input.scopes,
+                trigger: input.trigger,
+            },
+            tags: ["background-extraction", "langmem-aligned", "reusable_summaries", input.trigger],
+        }];
 }
 function normalizeKind(value, fallback) {
     if (value === "semantic" || value === "episodic" || value === "procedural") {
@@ -127,12 +138,41 @@ function normalizeScope(value, fallback) {
     }
     return fallback;
 }
+function extractAllowedScopes(candidate) {
+    const provenance = typeof candidate.provenance === "object" && candidate.provenance !== null && !Array.isArray(candidate.provenance)
+        ? candidate.provenance
+        : undefined;
+    const scopeOptions = provenance?.scopeOptions;
+    if (!Array.isArray(scopeOptions)) {
+        return undefined;
+    }
+    const allowed = scopeOptions
+        .filter((item) => item === "session" || item === "agent" || item === "workspace" || item === "user" || item === "project");
+    return allowed.length > 0 ? Array.from(new Set(allowed)) : undefined;
+}
+function normalizeScopeWithAllowedSet(value, fallback, allowedScopes) {
+    const normalized = normalizeScope(value, fallback);
+    if (!allowedScopes || allowedScopes.length === 0) {
+        return normalized;
+    }
+    if (normalized && allowedScopes.includes(normalized)) {
+        return normalized;
+    }
+    if (fallback && allowedScopes.includes(fallback)) {
+        return fallback;
+    }
+    return allowedScopes[0];
+}
 function normalizeTags(value, fallback) {
+    const fallbackTags = Array.isArray(fallback)
+        ? fallback.filter((item) => typeof item === "string" && item.trim().length > 0)
+        : [];
     if (!Array.isArray(value)) {
-        return fallback;
+        return fallbackTags.length > 0 ? fallbackTags : fallback;
     }
     const tags = value.filter((item) => typeof item === "string" && item.trim().length > 0);
-    return tags.length > 0 ? tags : fallback;
+    const merged = Array.from(new Set([...fallbackTags, ...tags]));
+    return merged.length > 0 ? merged : fallback;
 }
 function normalizeConfidence(value, fallback) {
     if (typeof value !== "number" || Number.isNaN(value)) {
@@ -140,15 +180,256 @@ function normalizeConfidence(value, fallback) {
     }
     return Math.min(1, Math.max(0, value));
 }
+function normalizeOperationalRule(value, fallback) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return fallback;
+    }
+    const typed = value;
+    const trigger = typeof typed.trigger === "string" && typed.trigger.trim().length > 0 ? typed.trigger.trim() : undefined;
+    const action = typeof typed.action === "string" && typed.action.trim().length > 0 ? typed.action.trim() : undefined;
+    const target = typeof typed.target === "string" && typed.target.trim().length > 0 ? typed.target.trim() : undefined;
+    const effect = typed.effect === "apply" || typed.effect === "invalidate"
+        ? typed.effect
+        : undefined;
+    if (!trigger || !action || !target) {
+        return fallback;
+    }
+    return { trigger, action, target, ...(effect ? { effect } : {}) };
+}
+function normalizeKnowledgeMutation(value, fallback) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return fallback;
+    }
+    const typed = value;
+    const identity = typeof typed.identity === "string" && typed.identity.trim().length > 0 ? typed.identity.trim() : undefined;
+    const operation = typed.operation === "create" || typed.operation === "update" || typed.operation === "delete"
+        ? typed.operation
+        : undefined;
+    if (!identity) {
+        return fallback;
+    }
+    return { identity, ...(operation ? { operation } : {}) };
+}
+function asCandidateOutputs(parsed, candidate, allowedScopes, recordedAt) {
+    const rawMutations = Array.isArray(parsed.mutations) ? parsed.mutations : undefined;
+    const outputs = rawMutations && rawMutations.length > 0
+        ? rawMutations.filter((item) => typeof item === "object" && item !== null && !Array.isArray(item))
+        : [parsed];
+    return outputs.map((output) => ({
+        ...candidate,
+        content: typeof output.content === "string" && output.content.trim().length > 0 ? output.content.trim() : candidate.content,
+        summary: typeof output.summary === "string" && output.summary.trim().length > 0 ? output.summary.trim() : candidate.summary,
+        kind: normalizeKind(output.kind, normalizeKind(candidate.kind, undefined)),
+        scope: normalizeScopeWithAllowedSet(output.scope, normalizeScope(candidate.scope, undefined), allowedScopes),
+        tags: normalizeTags(output.tags, candidate.tags),
+        confidence: normalizeConfidence(output.confidence, candidate.confidence),
+        knowledgeMutation: normalizeKnowledgeMutation(output.knowledgeMutation, candidate.knowledgeMutation),
+        operationalRule: normalizeOperationalRule(output.operationalRule, candidate.operationalRule),
+        observedAt: candidate.observedAt ?? recordedAt,
+    }));
+}
 function extractText(value) {
     if (typeof value === "string") {
         return value;
     }
-    if (typeof value === "object" && value !== null && "content" in value && typeof value.content === "string") {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    if ("content" in value && typeof value.content === "string") {
         return String(value.content);
     }
+    const kwargs = "kwargs" in value && typeof value.kwargs === "object" && value.kwargs !== null
+        ? value.kwargs
+        : undefined;
+    if (typeof kwargs?.content === "string") {
+        return kwargs.content;
+    }
     return undefined;
 }
+function normalizeCompareText(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function tokenizeText(value) {
+    return new Set(value
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/i)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2));
+}
+function jaccardTextSimilarity(left, right) {
+    const leftTokens = tokenizeText(left);
+    const rightTokens = tokenizeText(right);
+    if (leftTokens.size === 0 || rightTokens.size === 0) {
+        return 0;
+    }
+    let intersection = 0;
+    for (const token of leftTokens) {
+        if (rightTokens.has(token)) {
+            intersection += 1;
+        }
+    }
+    const union = new Set([...leftTokens, ...rightTokens]).size;
+    return union === 0 ? 0 : intersection / union;
+}
+function containsDeletionSignal(value) {
+    const normalized = normalizeCompareText(value);
+    if (!normalized) {
+        return false;
+    }
+    return [
+        "delete",
+        "deleted",
+        "remove",
+        "removed",
+        "revoked",
+        "forbidden",
+        "not allowed",
+        "no longer",
+        "unavailable",
+        "disabled",
+        "deprecated",
+        "取消",
+        "撤销",
+        "删除",
+        "已删除",
+        "删掉",
+        "移除",
+        "不再",
+        "不可用",
+        "不能",
+        "无法",
+        "禁用",
+        "废弃",
+    ].some((signal) => normalized.includes(signal));
+}
+function containsRuleTarget(candidate, record) {
+    const target = record.operationalRule?.target?.trim().toLowerCase();
+    if (!target) {
+        return false;
+    }
+    const candidateText = `${candidate.summary ?? ""}\n${candidate.content}`.toLowerCase();
+    return candidateText.includes(target);
+}
+function extractSalientLiterals(value) {
+    const results = new Set();
+    const normalized = value.trim();
+    if (!normalized) {
+        return results;
+    }
+    for (const match of normalized.matchAll(/[`'"]([^`'"]{1,64})[`'"]/g)) {
+        const literal = match[1]?.trim().toLowerCase();
+        if (literal && literal.length >= 2) {
+            results.add(literal);
+        }
+    }
+    for (const match of normalized.matchAll(/\b[a-z][a-z0-9._/-]{1,63}\b/gi)) {
+        const token = match[0]?.trim().toLowerCase();
+        if (token && !["system", "startup", "command", "memory", "instruction", "user", "deleted"].includes(token)) {
+            results.add(token);
+        }
+    }
+    return results;
+}
+function sharesSalientLiteral(candidate, record) {
+    const candidateLiterals = extractSalientLiterals(`${candidate.summary ?? ""}\n${candidate.content}`);
+    const recordLiterals = extractSalientLiterals(`${record.summary}\n${record.content}`);
+    if (candidateLiterals.size === 0 || recordLiterals.size === 0) {
+        return false;
+    }
+    for (const literal of candidateLiterals) {
+        if (recordLiterals.has(literal)) {
+            return true;
+        }
+    }
+    return false;
+}
+function selectMutationFallbackMatch(candidate, existingRecords) {
+    const candidateScope = normalizeScope(candidate.scope, undefined);
+    return existingRecords
+        .filter((record) => record.status === "active" && !!record.knowledgeIdentity && record.knowledgeOperation !== "delete")
+        .map((record) => {
+        let score = 0;
+        if (candidateScope && record.scope === candidateScope) {
+            score += 2;
+        }
+        if (containsRuleTarget(candidate, record)) {
+            score += 10;
+        }
+        if (sharesSalientLiteral(candidate, record)) {
+            score += 6;
+        }
+        if (record.operationalRule) {
+            score += 2;
+        }
+        return { record, score };
+    })
+        .filter((item) => item.score > 0)
+        .sort((left, right) => right.score - left.score || right.record.lastConfirmedAt.localeCompare(left.record.lastConfirmedAt))
+        .map((item) => item.record)
+        .at(0);
+}
+function applyDeterministicMutationFallback(candidate, existingRecords) {
+    const currentMutation = candidate.knowledgeMutation;
+    if (currentMutation && currentMutation.operation !== "create") {
+        return candidate;
+    }
+    if (!containsDeletionSignal(`${candidate.summary ?? ""}\n${candidate.content}`)) {
+        return candidate;
+    }
+    const matchingRule = selectMutationFallbackMatch(candidate, existingRecords);
+    if (!matchingRule?.knowledgeIdentity) {
+        return candidate;
+    }
+    return {
+        ...candidate,
+        scope: matchingRule.scope,
+        knowledgeMutation: {
+            identity: matchingRule.knowledgeIdentity,
+            operation: "delete",
+        },
+        ...(matchingRule.operationalRule
+            ? {
+                operationalRule: {
+                    ...matchingRule.operationalRule,
+                    effect: "invalidate",
+                },
+            }
+            : {}),
+    };
+}
+function selectRelatedContextRecords(candidate, existingRecords, maxRecords) {
+    const candidateScope = normalizeScope(candidate.scope, undefined);
+    const candidateSummary = normalizeCompareText(candidate.summary?.trim() || candidate.content);
+    const candidateContent = normalizeCompareText(candidate.content);
+    const candidateSourceRef = typeof candidate.sourceRef === "string" ? candidate.sourceRef.trim() : "";
+    return existingRecords
+        .filter((record) => record.status === "active")
+        .map((record) => {
+        let score = 0;
+        if (candidateScope && record.scope === candidateScope) {
+            score += 4;
+        }
+        if (candidateSourceRef && record.sourceRefs.includes(candidateSourceRef)) {
+            score += 12;
+        }
+        if (normalizeCompareText(record.summary) === candidateSummary) {
+            score += 10;
+        }
+        if (normalizeCompareText(record.content) === candidateContent) {
+            score += 9;
+        }
+        score += jaccardTextSimilarity(record.summary, candidate.summary ?? candidate.content) * 4;
+        score += jaccardTextSimilarity(record.content, candidate.content) * 3;
+        if (score > 0 && record.lastConfirmedAt) {
+            score += Math.max(0, 1 - ((Date.now() - Date.parse(record.lastConfirmedAt)) / (1000 * 60 * 60 * 24 * 365)));
+        }
+        return { record, score };
+    })
+        .filter((item) => item.score > 0)
+        .sort((left, right) => right.score - left.score || right.record.lastConfirmedAt.localeCompare(left.record.lastConfirmedAt))
+        .slice(0, maxRecords)
+        .map((item) => item.record);
+}
 function tryParseJsonObject(text) {
     try {
         const parsed = JSON.parse(text);
@@ -168,49 +449,83 @@ function tryParseJsonObject(text) {
         }
     }
 }
-function renderManagerPrompt(input) {
-    const existing = input.existingRecords.length === 0
-        ? "(none)"
-        : input.existingRecords
-            .map((record) => `- scope=${record.scope}; kind=${record.kind}; summary=${record.summary}; status=${record.status}; content=${record.content.replace(/\s+/g, " ").slice(0, 220)}`)
-            .join("\n");
-    return [
-        "You are the runtime memory manager.",
-        "Decide whether a candidate should be stored as durable memory and refine it if appropriate.",
-        "Return JSON only.",
-        "",
-        "Rules:",
-        '- Store only durable reusable knowledge. Reject transient chatter, scratchpad, or duplication without added value.',
-        '- Prefer semantic/episodic/procedural kinds only.',
-        '- Prefer scopes session/agent/workspace/user/project only.',
-        '- If the candidate should not be stored, return {"store": false, "reason": "..."}',
-        '- If it should be stored, return {"store": true, "content": "...", "summary": "...", "kind": "...", "scope": "...", "tags": ["..."], "confidence": 0.0}',
-        "",
-        `sessionId=${input.sessionId}`,
-        `requestId=${input.requestId}`,
-        "",
-        "Candidate:",
-        JSON.stringify(input.candidate, null, 2),
-        "",
-        "Existing relevant records:",
-        existing,
-    ].join("\n");
+async function reconcileKnowledgeMutation(input) {
+    const eligibleExisting = input.existingRecords.filter((record) => typeof record.knowledgeIdentity === "string" && record.knowledgeIdentity.trim().length > 0);
+    if (eligibleExisting.length === 0) {
+        return input.candidate;
+    }
+    const currentMutation = input.candidate.knowledgeMutation;
+    if (!currentMutation || currentMutation.operation !== "create") {
+        return input.candidate;
+    }
+    try {
+        const response = await input.invoker.invoke(renderRuntimeMemoryMutationReconciliationPrompt({
+            candidate: input.candidate,
+            existingRecords: eligibleExisting,
+        }), {});
+        const parsed = tryParseJsonObject(extractText(response) ?? "");
+        if (!parsed || parsed.reuseExistingIdentity !== true) {
+            return input.candidate;
+        }
+        const identity = typeof parsed.identity === "string" ? parsed.identity.trim() : "";
+        const matched = eligibleExisting.find((record) => record.knowledgeIdentity === identity);
+        if (!matched) {
+            return input.candidate;
+        }
+        const operation = parsed.operation === "update" || parsed.operation === "delete"
+            ? parsed.operation
+            : currentMutation.operation;
+        const reconciledScope = normalizeScopeWithAllowedSet(parsed.scope, matched.scope, extractAllowedScopes(input.candidate));
+        return {
+            ...input.candidate,
+            knowledgeMutation: {
+                identity,
+                operation,
+            },
+            scope: reconciledScope ?? input.candidate.scope ?? matched.scope,
+            operationalRule: operation === "delete" && matched.operationalRule
+                ? {
+                    ...matched.operationalRule,
+                    effect: "invalidate",
+                }
+                : input.candidate.operationalRule,
+        };
+    }
+    catch {
+        return input.candidate;
+    }
 }
 export async function runModelMemoryManager(input) {
-    const resolvedModel = await createResolvedModel(input.model, input.modelResolver);
+    let resolvedModel;
+    try {
+        resolvedModel = await createResolvedModel(input.model, input.modelResolver);
+    }
+    catch {
+        return input.candidates;
+    }
     const invoker = resolvedModel;
     if (typeof invoker.invoke !== "function") {
         return input.candidates;
     }
+    const callableInvoker = invoker;
     const transformed = [];
     for (const candidate of input.candidates) {
-        const prompt = renderManagerPrompt({
+        const allowedScopes = extractAllowedScopes(candidate);
+        const prompt = renderRuntimeMemoryManagerPrompt({
             candidate,
             sessionId: input.sessionId,
             requestId: input.requestId,
-            existingRecords: input.existingRecords,
+            existingRecords: selectRelatedContextRecords(candidate, input.existingRecords, input.maxContextRecords ?? input.existingRecords.length),
+            template: input.promptTemplate,
         });
-        const response = await invoker.invoke(prompt, {});
+        let response;
+        try {
+            response = await callableInvoker.invoke(prompt, {});
+        }
+        catch {
+            transformed.push(candidate);
+            continue;
+        }
         const parsed = tryParseJsonObject(extractText(response) ?? "");
         if (!parsed) {
             transformed.push(candidate);
@@ -219,16 +534,15 @@ export async function runModelMemoryManager(input) {
         if (parsed.store === false) {
             continue;
         }
-        transformed.push({
-            ...candidate,
-            content: typeof parsed.content === "string" && parsed.content.trim().length > 0 ? parsed.content.trim() : candidate.content,
-            summary: typeof parsed.summary === "string" && parsed.summary.trim().length > 0 ? parsed.summary.trim() : candidate.summary,
-            kind: normalizeKind(parsed.kind, normalizeKind(candidate.kind, undefined)),
-            scope: normalizeScope(parsed.scope, normalizeScope(candidate.scope, undefined)),
-            tags: normalizeTags(parsed.tags, candidate.tags),
-            confidence: normalizeConfidence(parsed.confidence, candidate.confidence),
-            observedAt: candidate.observedAt ?? input.recordedAt,
-        });
+        const refinedCandidates = asCandidateOutputs(parsed, candidate, allowedScopes, input.recordedAt);
+        for (const refinedCandidate of refinedCandidates) {
+            const reconciledCandidate = await reconcileKnowledgeMutation({
+                invoker: callableInvoker,
+                candidate: refinedCandidate,
+                existingRecords: selectRelatedContextRecords(refinedCandidate, input.existingRecords, input.maxContextRecords ?? input.existingRecords.length),
+            });
+            transformed.push(applyDeterministicMutationFallback(reconciledCandidate, input.existingRecords));
+        }
     }
     return transformed;
 }
@@ -239,9 +553,8 @@ export function createRuntimeMemoryManager(input) {
                 return candidates;
             }
             const contextRecords = existingRecords
-                .filter((record) => record.status === "active")
-                .slice(-input.config.manager.maxContextRecords);
-            if (input.config.manager.strategy !== "model") {
+                .filter((record) => record.status === "active");
+            if (input.config.manager.strategy === "rules") {
                 return candidates;
             }
             if (!binding.langchainAgentParams?.model) {
@@ -263,6 +576,8 @@ export function createRuntimeMemoryManager(input) {
                 requestId,
                 recordedAt,
                 existingRecords: contextRecords,
+                maxContextRecords: input.config.manager.maxContextRecords,
+                promptTemplate: input.config.manager.prompt,
                 modelResolver: input.modelResolver,
             });
         },

package/dist/runtime/harness/system/runtime-memory-policy.d.ts

@@ -4,6 +4,11 @@ export type ResolvedRuntimeMemoryPolicyConfig = {
         defaultTopK: number;
         maxPromptMemories: number;
     };
+    writePolicy: {
+        mode: "all" | "selective" | "disabled";
+        allow: string[];
+        deny: string[];
+    };
     namespaces: {
         session: string;
         workspace: string;
@@ -21,4 +26,18 @@ export declare function normalizeLangMemMemoryKind(kind: string | undefined): "s
 export declare function readRuntimeMemoryPolicyConfig(runtimeMemory: Record<string, unknown> | undefined, workspaceRoot: string): ResolvedRuntimeMemoryPolicyConfig | undefined;
 export declare function readRuntimeMemoryMaintenanceConfig(runtimeMemory: Record<string, unknown> | undefined): ResolvedRuntimeMemoryMaintenanceConfig | undefined;
 export declare function resolveMemoryNamespace(template: string, values: Record<string, string | undefined>): string[];
-export declare function scoreMemoryText(query: string, content: string, scopeBoost?: number): number;
+export declare function hasExplicitResourceReference(text: string): boolean;
+export declare function extractExplicitResourceReferences(text: string): string[];
+export declare function shouldRecallDurableMemory(text: string): boolean;
+export declare function collectMemoryCandidateLabels(candidate: {
+    kind?: string;
+    scope?: string;
+    sourceType?: string;
+    tags?: string[];
+}): string[];
+export declare function shouldStoreMemoryCandidate(policy: ResolvedRuntimeMemoryPolicyConfig | null | undefined, candidate: {
+    kind?: string;
+    scope?: string;
+    sourceType?: string;
+    tags?: string[];
+}): boolean;