om-memory-system 4.34.0-next.190 → 4.34.0

package/dist/services/chat/chat-answer.js

@@ -30,13 +30,17 @@ const SYSTEM = [
     "When the sources do not answer the question, say so briefly and set insufficient to true.",
     "Write plain, short British English. Call the answer tool.",
 ].join(" ");
+const SKILL_SYSTEM = "Sources marked K, such as [K1], are facts about one agent skill: uses, failed turns, whether it was changed, and its recent changes. Cite them like any other source.";
 export function numberSources(found) {
     return [
         ...found.memories.map((source, i) => ({ ...source, label: `S${i + 1}` })),
         ...found.profile.map((source, i) => ({ ...source, label: `P${i + 1}` })),
+        ...(found.skills ?? []).map((source, i) => ({ ...source, label: `K${i + 1}` })),
     ];
 }
 function describeSource(source) {
+    if (source.kind === "skill")
+        return `[${source.label}] ${source.text.slice(0, MAX_SOURCE_CHARS)}`;
     const meta = source.kind === "memory"
         ? [source.projectName, source.tags?.length ? `tags: ${source.tags.join(", ")}` : ""]
         : [source.section, source.category];
@@ -54,9 +58,12 @@ export function buildAnswerPrompt(question, turns, sources) {
     ]
         .filter(Boolean)
         .join("\n\n");
-    return { system: SYSTEM, user };
+    const system = sources.some((source) => source.kind === "skill")
+        ? `${SYSTEM} ${SKILL_SYSTEM}`
+        : SYSTEM;
+    return { system, user };
 }
-const MARKER = /\s*\[([SP]\d+)\]/g;
+const MARKER = /\s*\[([SPK]\d+)\]/g;
 /**
  * Removes `[S9]`-style markers that name a source that was not sent, and lists
  * the valid ones in order of first use. Other bracketed text is left alone.

package/dist/services/chat/chat-plan.d.ts

@@ -1,8 +1,10 @@
-import type { ChatPlanRecord, ChatRole } from "./chat-types.js";
+import type { ChatPlanRecord, ChatRole, SkillIntent } from "./chat-types.js";
 export declare const MAX_PLAN_TAGS = 200;
 export declare const MAX_PLAN_TURNS = 6;
 export declare const MAX_TURN_CHARS = 500;
 export declare const MAX_PLAN_QUERIES = 3;
+/** Skill names offered to the plan model, most used first. */
+export declare const MAX_PLAN_SKILLS = 100;
 export interface PlanInput {
     question: string;
     turns: Array<{
@@ -14,6 +16,8 @@ export interface PlanInput {
         count: number;
     }>;
     categories: string[];
+    /** Safe skill names, most used first. Absent while skill facts are off. */
+    skills?: string[];
 }
 export declare const PLAN_TOOL: {
     readonly type: "function";
@@ -49,6 +53,54 @@ export declare const PLAN_TOOL: {
         };
     };
 };
+/** The plan tool while skill facts are on: two optional fields on top of `PLAN_TOOL`. */
+export declare const PLAN_TOOL_WITH_SKILLS: {
+    readonly type: "function";
+    readonly function: {
+        readonly parameters: {
+            readonly properties: {
+                readonly skills: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Skills from the given list that the question names or is about";
+                };
+                readonly skillIntent: {
+                    readonly type: "string";
+                    readonly enum: readonly SkillIntent[];
+                    readonly description: "needs-work for skills that fail or need care, most-used for skills used most, otherwise none";
+                };
+                readonly queries: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "1 to 3 short search phrases";
+                };
+                readonly tags: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Tags from the given list that match the question";
+                };
+                readonly profileCategories: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                    readonly description: "Profile categories from the given list that match the question";
+                };
+            };
+            readonly type: "object";
+            readonly required: readonly ["queries", "tags", "profileCategories"];
+        };
+        readonly name: "plan_search";
+        readonly description: "Choose how to search the user's stored memories and profile";
+    };
+};
+export declare function planTool(withSkills: boolean): typeof PLAN_TOOL | typeof PLAN_TOOL_WITH_SKILLS;
 export declare function buildPlanPrompt(input: PlanInput): {
     system: string;
     user: string;

package/dist/services/chat/chat-plan.js

@@ -2,6 +2,9 @@ export const MAX_PLAN_TAGS = 200;
 export const MAX_PLAN_TURNS = 6;
 export const MAX_TURN_CHARS = 500;
 export const MAX_PLAN_QUERIES = 3;
+/** Skill names offered to the plan model, most used first. */
+export const MAX_PLAN_SKILLS = 100;
+const SKILL_INTENTS = ["none", "needs-work", "most-used"];
 export const PLAN_TOOL = {
     type: "function",
     function: {
@@ -30,6 +33,32 @@ export const PLAN_TOOL = {
         },
     },
 };
+/** The plan tool while skill facts are on: two optional fields on top of `PLAN_TOOL`. */
+export const PLAN_TOOL_WITH_SKILLS = {
+    type: "function",
+    function: {
+        ...PLAN_TOOL.function,
+        parameters: {
+            ...PLAN_TOOL.function.parameters,
+            properties: {
+                ...PLAN_TOOL.function.parameters.properties,
+                skills: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Skills from the given list that the question names or is about",
+                },
+                skillIntent: {
+                    type: "string",
+                    enum: [...SKILL_INTENTS],
+                    description: "needs-work for skills that fail or need care, most-used for skills used most, otherwise none",
+                },
+            },
+        },
+    },
+};
+export function planTool(withSkills) {
+    return withSkills ? PLAN_TOOL_WITH_SKILLS : PLAN_TOOL;
+}
 const SYSTEM = [
     "You plan a search over one user's saved memories of past coding sessions and their profile.",
     "Return 1 to 3 short search phrases that would find memories answering the question.",
@@ -37,6 +66,11 @@ const SYSTEM = [
     "Pick tags and profile categories only from the lists given. Pick none when none fit.",
     "Call plan_search. Do not answer the question.",
 ].join(" ");
+const SKILL_SYSTEM = [
+    "The question may also be about the user's agent skills.",
+    "Pick skills only from the Skills list. Set skillIntent to needs-work for questions about skills that fail or need care,",
+    "to most-used for questions about the skills used most, and to none otherwise.",
+].join(" ");
 function topTags(tags) {
     return [...tags].sort((a, b) => b.count - a.count).slice(0, MAX_PLAN_TAGS);
 }
@@ -46,13 +80,15 @@ export function buildPlanPrompt(input) {
         .map((turn) => `${turn.role}: ${turn.content.slice(0, MAX_TURN_CHARS)}`);
     const tags = topTags(input.tags).map((tag) => `${tag.keyword} (${tag.count})`);
     const categories = [...new Set(input.categories)];
+    const skills = input.skills ? [...new Set(input.skills)].slice(0, MAX_PLAN_SKILLS) : null;
     const user = [
         turns.length ? `Earlier turns:\n${turns.join("\n")}` : "Earlier turns: none",
         `Tags (count): ${tags.length ? tags.join(", ") : "none"}`,
         `Profile categories: ${categories.length ? categories.join(", ") : "none"}`,
+        ...(skills ? [`Skills: ${skills.length ? skills.join(", ") : "none"}`] : []),
         `Question: ${input.question}`,
     ].join("\n\n");
-    return { system: SYSTEM, user };
+    return { system: skills ? `${SYSTEM} ${SKILL_SYSTEM}` : SYSTEM, user };
 }
 function strings(value) {
     if (!Array.isArray(value))
@@ -83,10 +119,15 @@ export function validatePlan(raw, input) {
     if (queries.length === 0) {
         return { queries: [input.question], tags: [], profileCategories: [], skipped: true };
     }
-    return {
+    const record = {
         queries,
         tags: known(strings(plan.tags), topTags(input.tags).map((tag) => tag.keyword)),
         profileCategories: known(strings(plan.profileCategories), input.categories),
         skipped: false,
     };
+    if (input.skills) {
+        record.skills = known(strings(plan.skills), input.skills.slice(0, MAX_PLAN_SKILLS));
+        record.skillIntent = SKILL_INTENTS.find((intent) => intent === plan.skillIntent) ?? "none";
+    }
+    return record;
 }

package/dist/services/chat/chat-retrieve.d.ts

@@ -31,6 +31,8 @@ export interface RetrieveDeps {
 export interface RetrievedSources {
     memories: ChatSource[];
     profile: ChatSource[];
+    /** Skill facts. Added by the service while skill facts are on; retrieval never sets it. */
+    skills?: ChatSource[];
 }
 /** Memory and profile sources for one question, searched in parallel. */
 export declare function retrieveSources(question: string, plan: ChatPlanRecord, scopeTag: string | null, deps: RetrieveDeps): Promise<RetrievedSources>;

package/dist/services/chat/chat-routes.js

@@ -1,6 +1,6 @@
 import { tryExtractScopeFromContainerTag } from "../memory-scope.js";
 import { log } from "../logger.js";
-import { chatServiceDeps, chatStore, existingMemoryIds, } from "./chat-runtime.js";
+import { chatServiceDeps, chatStore, existingMemoryIds, listedSkillNames, } from "./chat-runtime.js";
 import { askQuestion } from "./chat-service.js";
 import { chatStatus } from "./chat-status.js";
 import { ChatStoreError } from "./chat-types.js";
@@ -24,6 +24,21 @@ function folderId(value) {
 const CONVERSATION = /^\/api\/chat\/conversations\/([^/]+)$/;
 const MESSAGES = /^\/api\/chat\/conversations\/([^/]+)\/messages$/;
 const FOLDER = /^\/api\/chat\/folders\/([^/]+)$/;
+/**
+ * The `K` source names that the current ranking no longer lists. Empty while
+ * skill learning is off, and empty, with no error, when the ranking cannot be read.
+ */
+async function missingSkillNames(messages, config) {
+    if (config.skillLearning !== true)
+        return [];
+    const cited = [
+        ...new Set(messages.flatMap((m) => m.sources.filter((s) => s.kind === "skill").map((s) => s.id))),
+    ];
+    if (cited.length === 0)
+        return [];
+    const listed = await listedSkillNames(config).catch(() => null);
+    return listed ? cited.filter((name) => !listed.has(name)) : [];
+}
 /**
  * The chat routes under `/api/chat/`. Returns undefined for any other path.
  * Store errors map to 400, 404 or 409; anything else is logged by code only.
@@ -103,6 +118,7 @@ async function dispatch(path, method, readBody, config) {
             return ok({
                 ...found,
                 missingMemoryIds: cited.filter((memoryId) => !existing.has(memoryId)),
+                missingSkillNames: await missingSkillNames(found.messages, config),
             });
         }
         if (method === "PATCH") {

package/dist/services/chat/chat-runtime.d.ts

@@ -1,9 +1,11 @@
 import type { ChatServiceDeps } from "./chat-service.js";
 import { ChatStore } from "./chat-store.js";
+import { type ChatSkillsConfig } from "./chat-skills-runtime.js";
+export { listedSkillNames } from "./chat-skills-runtime.js";
 /** Each model call gets this long before chat gives up on it. */
 export declare const CHAT_MODEL_TIMEOUT_MS = 60000;
 /** The settings chat reads. The caller passes `CONFIG`. */
-export interface ChatRuntimeConfig {
+export interface ChatRuntimeConfig extends Partial<Omit<ChatSkillsConfig, "storagePath">> {
     storagePath: string;
     memoryProvider: string;
     memoryModel?: string;

package/dist/services/chat/chat-runtime.js

@@ -1,6 +1,8 @@
 import { join } from "node:path";
 import { log } from "../logger.js";
 import { ChatStore } from "./chat-store.js";
+import { chatSkillsDep } from "./chat-skills-runtime.js";
+export { listedSkillNames } from "./chat-skills-runtime.js";
 /** Each model call gets this long before chat gives up on it. */
 export const CHAT_MODEL_TIMEOUT_MS = 60_000;
 const stores = new Map();
@@ -74,8 +76,10 @@ export async function existingMemoryIds(ids) {
 /** Real dependencies for `askQuestion`, built from the settings passed in. */
 export async function chatServiceDeps(config) {
     const store = await chatStore(config);
+    const skills = await chatSkillsDep(config);
     return {
         store,
+        ...(skills ? { skills } : {}),
         model: config.memoryModel ?? config.memoryProvider,
         callTool: (system, user, tool) => callTool(config, system, user, tool),
         retrieve: {

package/dist/services/chat/chat-service.d.ts

@@ -1,11 +1,12 @@
 import type { ToolCallResult } from "../ai/providers/base-provider.js";
 import { ANSWER_TOOL } from "./chat-answer.js";
-import { PLAN_TOOL, type PlanInput } from "./chat-plan.js";
+import { planTool, type PlanInput } from "./chat-plan.js";
 import { type RetrieveDeps } from "./chat-retrieve.js";
+import { type ChatSkillsDep } from "./chat-skills.js";
 import type { ChatStore } from "./chat-store.js";
 import type { ChatMessage } from "./chat-types.js";
 export declare const MAX_QUESTION_CHARS = 4000;
-type Tool = typeof PLAN_TOOL | typeof ANSWER_TOOL;
+type Tool = ReturnType<typeof planTool> | typeof ANSWER_TOOL;
 export interface ChatServiceDeps {
     store: ChatStore;
     model: string;
@@ -14,6 +15,8 @@ export interface ChatServiceDeps {
     retrieve: RetrieveDeps;
     listTags: (scopeTag: string | null) => Promise<PlanInput["tags"]>;
     profileCategories: () => Promise<string[]>;
+    /** Skill facts. Present only while `skillLearning` is on; absent means today's behaviour. */
+    skills?: ChatSkillsDep;
     /** Metadata only: sizes, counts, codes, timings. Never question or answer text. */
     log: (message: string, meta: Record<string, unknown>) => void;
 }

package/dist/services/chat/chat-service.js

@@ -1,7 +1,8 @@
 import { isFullyPrivate, stripPrivateContent } from "../privacy.js";
 import { ANSWER_TOOL, buildAnswerPrompt, finaliseAnswer, numberSources } from "./chat-answer.js";
-import { PLAN_TOOL, buildPlanPrompt, validatePlan } from "./chat-plan.js";
+import { buildPlanPrompt, planTool, validatePlan } from "./chat-plan.js";
 import { retrieveSources } from "./chat-retrieve.js";
+import { readSkillRows, skillSourcesFor, failureCode } from "./chat-skills.js";
 export const MAX_QUESTION_CHARS = 4000;
 const TITLE_CHARS = 60;
 const DEFAULT_TITLE = "New chat";
@@ -26,7 +27,7 @@ async function safeCall(deps, system, user, tool) {
 }
 async function plan(deps, input) {
     const prompt = buildPlanPrompt(input);
-    const result = await safeCall(deps, prompt.system, prompt.user, PLAN_TOOL);
+    const result = await safeCall(deps, prompt.system, prompt.user, planTool(!!input.skills));
     return validatePlan(result?.success ? result.data : null, input);
 }
 /**
@@ -77,10 +78,36 @@ export async function askQuestion(conversationId, input, deps) {
         deps.listTags(input.scopeTag).catch(() => []),
         deps.profileCategories().catch(() => []),
     ]);
-    const searchPlan = await plan(deps, { question, turns, tags, categories });
+    const read = deps.skills ? await readSkillRows(deps.skills) : null;
+    const rows = read && "rows" in read ? read.rows : null;
+    const searchPlan = await plan(deps, {
+        question,
+        turns,
+        tags,
+        categories,
+        ...(rows ? { skills: rows.map((row) => row.name) } : {}),
+    });
+    const markUnavailable = (reason) => {
+        searchPlan.skillFacts = "unavailable";
+        deps.log("chat: skill facts unavailable", { conversationId, reason });
+    };
+    if (read && "failure" in read)
+        markUnavailable(read.failure);
+    let skillSources = [];
+    if (deps.skills && rows) {
+        try {
+            skillSources = await skillSourcesFor(deps.skills, rows, searchPlan, question);
+        }
+        catch (error) {
+            markUnavailable(failureCode(error));
+        }
+    }
     let sources;
     try {
-        sources = numberSources(await retrieveSources(question, searchPlan, input.scopeTag, deps.retrieve));
+        sources = numberSources({
+            ...(await retrieveSources(question, searchPlan, input.scopeTag, deps.retrieve)),
+            skills: skillSources,
+        });
     }
     catch {
         return save(deps, conversationId, { errorCode: "search_failed", plan: searchPlan }, started);
@@ -121,6 +148,9 @@ async function save(deps, conversationId, out, started) {
         tags: out.plan.tags.length,
         categories: out.plan.profileCategories.length,
         sources: out.sources?.length ?? 0,
+        ...(deps.skills
+            ? { skillSources: out.sources?.filter((s) => s.kind === "skill").length ?? 0 }
+            : {}),
         cited: out.cited ?? 0,
         answerChars: out.content?.length ?? 0,
         ms: Date.now() - started,

package/dist/services/chat/chat-skills-runtime.d.ts

@@ -0,0 +1,21 @@
+import { type ChatSkillsDep } from "./chat-skills.js";
+/** The settings the skill reader needs. The caller passes `CONFIG`. */
+export interface ChatSkillsConfig {
+    storagePath: string;
+    skillLearning?: boolean;
+    skillStoragePath?: string;
+    skillFolders?: string[];
+    claudeConfigDir?: string;
+    memoryApiKey?: string;
+    embeddingApiKey?: string;
+    webServerApiToken?: string;
+    webServerAuthPassword?: string;
+}
+/**
+ * The skill reader for the chat, or undefined while `skillLearning` is off.
+ * It opens `skills.db` with `existingDb()` and never calls `init()`, so it
+ * never creates or changes the file. A newer schema version is an error.
+ */
+export declare function chatSkillsDep(config: ChatSkillsConfig): Promise<ChatSkillsDep | undefined>;
+/** The names the current ranking lists, or null when the ranking cannot be read. */
+export declare function listedSkillNames(config: ChatSkillsConfig): Promise<Set<string> | null>;

package/dist/services/chat/chat-skills-runtime.js

@@ -0,0 +1,47 @@
+import { makeScrubContext, SkillFactsError, } from "./chat-skills.js";
+import { MAX_HISTORY_ENTRIES } from "./chat-skills.js";
+/**
+ * The skill reader for the chat, or undefined while `skillLearning` is off.
+ * It opens `skills.db` with `existingDb()` and never calls `init()`, so it
+ * never creates or changes the file. A newer schema version is an error.
+ */
+export async function chatSkillsDep(config) {
+    if (config.skillLearning !== true)
+        return undefined;
+    const [{ SkillStore, skillsDbPath, SKILL_SCHEMA_VERSION }, folders, indexModule, ranking, hist] = await Promise.all([
+        import("../skill-learning/store.js"),
+        import("../skill-learning/skill-folders.js"),
+        import("../skill-learning/skill-index.js"),
+        import("../skill-learning/ranking.js"),
+        import("../skill-learning/history.js"),
+    ]);
+    const store = new SkillStore(skillsDbPath(folders.skillStoragePath(config)));
+    const watched = folders.watchedSkillFolders(config);
+    return {
+        scrub: makeScrubContext(config),
+        rank: async () => {
+            const db = await store.existingDb();
+            if (db) {
+                const row = await db.get("SELECT value FROM skill_meta WHERE key = 'schema_version'");
+                if (row && Number(row.value) > SKILL_SCHEMA_VERSION) {
+                    throw new SkillFactsError("newer_schema");
+                }
+            }
+            const now = Date.now();
+            return ranking.rankSkills(store, indexModule.getSkillIndex(watched, now), now, "uses");
+        },
+        history: async (row) => (await hist.skillHistory({ store, folders: watched }, { path: row.path ?? undefined, name: row.name }, MAX_HISTORY_ENTRIES, 0)).entries,
+    };
+}
+/** The names the current ranking lists, or null when the ranking cannot be read. */
+export async function listedSkillNames(config) {
+    const skills = await chatSkillsDep(config);
+    if (!skills)
+        return null;
+    try {
+        return new Set((await skills.rank()).map((row) => row.name));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/services/chat/chat-skills.d.ts

@@ -0,0 +1,85 @@
+import { type CaptureDiagnosticsConfig } from "../capture-diagnostics.js";
+import type { SkillHistoryEntry } from "../skill-learning/history.js";
+import type { SkillRanking } from "../skill-learning/ranking.js";
+import { MAX_PLAN_SKILLS } from "./chat-plan.js";
+import type { ChatSource, SkillIntent } from "./chat-types.js";
+export { MAX_PLAN_SKILLS };
+export type { SkillIntent };
+/** Skill sources per question. Memories (12) and profile items (6) have their own limits. */
+export declare const MAX_SKILL_SOURCES = 6;
+export declare const MAX_SUMMARY_CHARS = 200;
+export declare const MAX_HISTORY_ENTRIES = 5;
+/** The only names the chat offers, accepts or saves. */
+export declare const SAFE_SKILL_NAME: RegExp;
+/** The part of a ranking row that the chat uses. The `path` is read here and never copied out. */
+export type SkillRow = Pick<SkillRanking, "name" | "path" | "uses" | "failedTurns" | "attention" | "modified" | "lastAppliedAt">;
+type HistoryInput = Pick<SkillHistoryEntry, "kind" | "at" | "summary" | "appliedBy">;
+/** Why skill facts could not be read. Logged as a code; never as text. */
+export type SkillFactsFailure = "newer_schema" | "read_failed";
+export declare class SkillFactsError extends Error {
+    readonly code: SkillFactsFailure;
+    constructor(code: SkillFactsFailure);
+}
+/** How the chat reads skill facts. Built only while `skillLearning` is on. */
+export interface ChatSkillsDep {
+    scrub: ScrubContext;
+    /** Ranking rows in any order. Throws when `skills.db` is newer or unreadable. */
+    rank: () => Promise<SkillRow[]>;
+    /** History entries of one skill, newest first. */
+    history: (row: SkillRow) => Promise<HistoryInput[]>;
+}
+export interface ScrubContext {
+    home: string;
+    user: string;
+    diagnostics: CaptureDiagnosticsConfig;
+}
+/** Reads the home folder and OS user name when none are given. Pass config values in; do not import `CONFIG`. */
+export declare function makeScrubContext(diagnostics: CaptureDiagnosticsConfig, names?: {
+    home?: string;
+    user?: string;
+}): ScrubContext;
+/**
+ * A summary made safe to send and to save: no `<private>` text, no secrets, no
+ * home folder, OS user name, absolute path or email address, and at most 200
+ * characters. It runs whatever `skillLearningRedact` says.
+ */
+export declare function scrubSummary(text: string, ctx: ScrubContext): string;
+/**
+ * Rows with a safe name, one per name, most used first, at most 100. When two
+ * rows share a name, the one with the most uses wins; the first wins a tie.
+ */
+export declare function safeSkillRows<T extends SkillRow>(rows: readonly T[], ctx: ScrubContext): T[];
+/**
+ * Up to six rows: named skills first in plan order, then the rows the intent
+ * picks. `rows` must come from `safeSkillRows`.
+ */
+export declare function selectSkills<T extends SkillRow>(rows: readonly T[], named: readonly string[], intent: SkillIntent): T[];
+/**
+ * Skill names that appear in the question as a whole token, ignoring case, in
+ * order of first mention. Names under 3 characters are skipped. A name is not
+ * matched inside a longer name such as `s-web-search-v2`.
+ */
+export declare function matchSkillNames(question: string, names: readonly string[]): string[];
+/**
+ * The `K` source for one skill. The label comes later from `numberSources`.
+ * `history` is newest first; the newest 5 entries are kept. No path, version
+ * id or undo flag leaves this function.
+ */
+export declare function buildSkillSource(row: SkillRow, history: readonly HistoryInput[], ctx: ScrubContext): ChatSource;
+/** The reason code for a failed read. */
+export declare function failureCode(error: unknown): SkillFactsFailure;
+/** The safe skill rows, or the reason they could not be read. */
+export declare function readSkillRows(skills: ChatSkillsDep): Promise<{
+    rows: SkillRow[];
+} | {
+    failure: SkillFactsFailure;
+}>;
+/**
+ * The `K` sources for one question. The plan's names come first, or the names
+ * found in the question when the plan was skipped. Throws when history cannot be read.
+ */
+export declare function skillSourcesFor(skills: ChatSkillsDep, rows: readonly SkillRow[], plan: {
+    skipped: boolean;
+    skills?: string[];
+    skillIntent?: SkillIntent;
+}, question: string): Promise<ChatSource[]>;