@dory-agentic/dory-agentic-sdk 0.2.0

package/dist/lfs/types.d.ts

@@ -0,0 +1,44 @@
+export type { AdaptiveMessage as LfsMessage, MemoryChunk, TurnMemorySnapshot, AllocationMap } from "./tokenCounter";
+export type { ContextShift } from "./memoryParser";
+export type LfsLane = "standard" | "optimized";
+export type SessionStoreState = {
+    sessionId: string;
+    fullHistory: import("./tokenCounter").AdaptiveMessage[];
+    longTermMemory: Record<string, import("./tokenCounter").MemoryChunk>;
+    forgetScores: Record<string, number>;
+    agentWeights: Record<string, number>;
+    contextMax: number;
+    memoryCapFraction: number;
+    turnIndex: number;
+};
+export type PrepareStepInput = {
+    sessionId: string;
+    lane: LfsLane;
+    incomingMessages: import("./tokenCounter").AdaptiveMessage[];
+    contextMax: number;
+    memoryCapFraction?: number;
+    benchmarkSuite?: boolean;
+    stepNumber?: number;
+    query?: string;
+    turnIndex?: number;
+    agentWeights?: Record<string, number>;
+    hydrationBeacon?: string;
+    enableReflection?: boolean;
+    useRemindTool?: boolean;
+    /** When true, incomingMessages replace session history instead of merging. */
+    replaceSessionHistory?: boolean;
+};
+export type PrepareStepOutput = {
+    lane: LfsLane;
+    executionLane: "PASS_THRU" | "ELASTIC_SWAP";
+    isMmuActive: boolean;
+    messagesForModel: Array<{
+        role: string;
+        content: string;
+    }>;
+    systemBlocks: string[];
+    session: SessionStoreState;
+    budget?: number;
+    remindClause?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lfs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lfs/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,eAAe,IAAI,UAAU,EAAE,WAAW,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpH,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAE/C,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACxD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,gBAAgB,EAAE,WAAW,CAAC,CAAC;IACrE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,OAAO,gBAAgB,EAAE,eAAe,EAAE,CAAC;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,8EAA8E;IAC9E,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,aAAa,EAAE,WAAW,GAAG,cAAc,CAAC;IAC5C,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC"}

package/dist/lfs/types.js

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

package/dist/lfs/vectorDb.d.ts

@@ -0,0 +1,19 @@
+export declare function generateLocalEmbedding(text: string): Promise<number[]>;
+export interface ChunkRecord {
+    chunkId: string;
+    parentMessageId: string;
+    vector: number[];
+    isArchived: boolean;
+    timestamp: number;
+}
+export declare function upsertChunkVector(chunkId: string, parentMessageId: string, text: string): Promise<void>;
+export declare function setChunkArchiveStatus(chunkId: string, isArchived: boolean): void;
+export declare function clearVectorCache(): void;
+export declare function queryChunkVectorCache(queryText: string, limit?: number): Promise<{
+    chunkId: string;
+    parentMessageId: string;
+    score: number;
+}[]>;
+export declare function upsertVector(messageId: string, text: string): Promise<void>;
+export declare function queryVectorCache(queryText: string, limit?: number): Promise<string[]>;
+//# sourceMappingURL=vectorDb.d.ts.map

package/dist/lfs/vectorDb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vectorDb.d.ts","sourceRoot":"","sources":["../../src/lfs/vectorDb.ts"],"names":[],"mappings":"AAkFA,wBAAsB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAkC5E;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CASf;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAG,IAAI,CAIhF;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAIvC;AAWD,wBAAsB,qBAAqB,CACzC,SAAS,EAAE,MAAM,EACjB,KAAK,SAAI,GACR,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAexE;AAED,wBAAsB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjF;AAED,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGtF"}

package/dist/lfs/vectorDb.js

@@ -0,0 +1,158 @@
+import { estimateTextTokens } from "./tokenCounter";
+/**
+ * 128-dimensional deterministic character-hash-based vectorizer.
+ * Guarantees fast offline execution; dot product equals cosine similarity after L2 norm.
+ */
+function generateHashEmbedding(text) {
+    const dims = 128;
+    const vector = new Array(dims).fill(0);
+    if (!text || !text.trim())
+        return vector;
+    const words = text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 1);
+    if (words.length === 0)
+        return vector;
+    for (const word of words) {
+        let hash = 5381;
+        for (let i = 0; i < word.length; i++) {
+            hash = (hash * 33) ^ word.charCodeAt(i);
+        }
+        const idx = Math.abs(hash) % dims;
+        vector[idx] += 1;
+    }
+    let sumSq = 0;
+    for (let i = 0; i < dims; i++) {
+        sumSq += vector[i] * vector[i];
+    }
+    const norm = Math.sqrt(sumSq);
+    if (norm > 0) {
+        for (let i = 0; i < dims; i++) {
+            vector[i] /= norm;
+        }
+    }
+    return vector;
+}
+function sliceTextIntoSubTokens(text, maxTokens = 512) {
+    if (!text || !text.trim())
+        return [];
+    const lines = text.split("\n");
+    const slices = [];
+    let currentSlice = "";
+    for (const line of lines) {
+        const lineWithNL = line + "\n";
+        if (estimateTextTokens(currentSlice + lineWithNL) <= maxTokens) {
+            currentSlice += lineWithNL;
+        }
+        else {
+            if (currentSlice.trim()) {
+                slices.push(currentSlice);
+            }
+            currentSlice = lineWithNL;
+            if (estimateTextTokens(currentSlice) > maxTokens) {
+                const words = currentSlice.split(/\s+/);
+                let part = "";
+                for (const word of words) {
+                    const proposed = part ? part + " " + word : word;
+                    if (estimateTextTokens(proposed) <= maxTokens) {
+                        part = proposed;
+                    }
+                    else {
+                        if (part.trim())
+                            slices.push(part);
+                        part = word;
+                    }
+                }
+                currentSlice = part;
+            }
+        }
+    }
+    if (currentSlice.trim()) {
+        slices.push(currentSlice);
+    }
+    return slices;
+}
+export async function generateLocalEmbedding(text) {
+    const tokenEst = estimateTextTokens(text);
+    if (tokenEst > 512) {
+        const slices = sliceTextIntoSubTokens(text, 512);
+        if (slices.length > 1) {
+            const vectors = await Promise.all(slices.map((s) => generateLocalEmbedding(s)));
+            const dims = vectors[0].length;
+            const centroid = new Array(dims).fill(0);
+            for (const vec of vectors) {
+                for (let i = 0; i < dims; i++) {
+                    centroid[i] += vec[i];
+                }
+            }
+            for (let i = 0; i < dims; i++) {
+                centroid[i] /= vectors.length;
+            }
+            let sumSq = 0;
+            for (let i = 0; i < dims; i++) {
+                sumSq += centroid[i] * centroid[i];
+            }
+            const norm = Math.sqrt(sumSq);
+            if (norm > 0) {
+                for (let i = 0; i < dims; i++) {
+                    centroid[i] /= norm;
+                }
+            }
+            return centroid;
+        }
+    }
+    return generateHashEmbedding(text);
+}
+const chunkVectorCache = {};
+export async function upsertChunkVector(chunkId, parentMessageId, text) {
+    const vector = await generateLocalEmbedding(text);
+    chunkVectorCache[chunkId] = {
+        chunkId,
+        parentMessageId,
+        vector,
+        isArchived: false,
+        timestamp: Date.now(),
+    };
+}
+export function setChunkArchiveStatus(chunkId, isArchived) {
+    if (chunkVectorCache[chunkId]) {
+        chunkVectorCache[chunkId].isArchived = isArchived;
+    }
+}
+export function clearVectorCache() {
+    for (const key in chunkVectorCache) {
+        delete chunkVectorCache[key];
+    }
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+    }
+    return dotProduct;
+}
+export async function queryChunkVectorCache(queryText, limit = 5) {
+    const queryVector = await generateLocalEmbedding(queryText);
+    const matches = [];
+    for (const record of Object.values(chunkVectorCache)) {
+        const score = cosineSimilarity(queryVector, record.vector);
+        matches.push({
+            chunkId: record.chunkId,
+            parentMessageId: record.parentMessageId,
+            score,
+        });
+    }
+    matches.sort((a, b) => b.score - a.score);
+    return matches.slice(0, limit).filter((m) => m.score > 0.05);
+}
+export async function upsertVector(messageId, text) {
+    await upsertChunkVector(`${messageId}_chunk_0`, messageId, text);
+}
+export async function queryVectorCache(queryText, limit = 5) {
+    const matches = await queryChunkVectorCache(queryText, limit);
+    return Array.from(new Set(matches.map((m) => m.parentMessageId)));
+}

package/dist/mcp/client.d.ts

@@ -0,0 +1,23 @@
+import type { ToolSet } from "ai";
+export type McpClientOptions = {
+    command: string;
+    args: string[];
+    allowlist?: {
+        command: string;
+        argsPrefix?: string[];
+    };
+};
+export type McpClientHandle = {
+    tools: () => Promise<ToolSet>;
+    close: () => Promise<void>;
+};
+export declare function createFetchMcpClient(opts: McpClientOptions): Promise<McpClientHandle>;
+export declare function listMcpTools(opts: McpClientOptions): Promise<ToolSet>;
+export declare function callMcpTool(opts: McpClientOptions, toolName: string, args: Record<string, unknown>): Promise<{
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    error: string;
+}>;
+//# sourceMappingURL=client.d.ts.map

package/dist/mcp/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/mcp/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAGlC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACxD,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAqBF,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAU3F;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,gBAAgB,oBAOxD;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAmBvE"}

package/dist/mcp/client.js

@@ -0,0 +1,60 @@
+import { experimental_createMCPClient as createMcpClient } from "@ai-sdk/mcp";
+import { validateFetchUrl } from "./config";
+function validateMcpSpawn(opts) {
+    if (opts.allowlist) {
+        const { command, argsPrefix = [] } = opts.allowlist;
+        if (opts.command !== command) {
+            throw new Error(`MCP command not allowed: ${opts.command}`);
+        }
+        for (let i = 0; i < argsPrefix.length; i++) {
+            if (opts.args[i] !== argsPrefix[i]) {
+                throw new Error("MCP args do not match allowlist prefix");
+            }
+        }
+    }
+    const combined = `${opts.command} ${opts.args.join(" ")}`;
+    if (/[;&|`$<>]/.test(combined)) {
+        throw new Error("MCP command contains disallowed shell metacharacters");
+    }
+}
+export async function createFetchMcpClient(opts) {
+    validateMcpSpawn(opts);
+    const client = await createMcpClient({
+        transport: {
+            type: "stdio",
+            command: opts.command,
+            args: opts.args,
+        },
+    });
+    return client;
+}
+export async function listMcpTools(opts) {
+    const client = await createFetchMcpClient(opts);
+    try {
+        return await client.tools();
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function callMcpTool(opts, toolName, args) {
+    if (typeof args.url === "string") {
+        const checked = validateFetchUrl(args.url);
+        if (!checked.ok)
+            return { ok: false, error: checked.error };
+    }
+    const client = await createFetchMcpClient(opts);
+    try {
+        const tools = await client.tools();
+        const tool = tools[toolName];
+        if (!tool?.execute)
+            return { ok: false, error: `Unknown MCP tool: ${toolName}` };
+        return { ok: true, result: await tool.execute(args) };
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+    finally {
+        await client.close();
+    }
+}

package/dist/mcp/config.d.ts

@@ -0,0 +1,10 @@
+export declare const MCP_TOOL_RESULT_MAX_CHARS = 8000;
+export declare function getFetchUrlAllowlist(): Set<string> | null;
+export declare function isPrivateHost(hostname: string): boolean;
+export declare function validateFetchUrl(url: string): {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/mcp/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/mcp/config.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,yBAAyB,OAAO,CAAC;AAE9C,wBAAgB,oBAAoB,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAWzD;AAiBD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAmBvD;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAqBzF"}

package/dist/mcp/config.js

@@ -0,0 +1,72 @@
+import { isIP } from "node:net";
+export const MCP_TOOL_RESULT_MAX_CHARS = 8000;
+export function getFetchUrlAllowlist() {
+    const raw = process.env.DORY_AGENTIC_MCP_FETCH_ALLOWLIST?.trim() ||
+        process.env.MCP_FETCH_URL_ALLOWLIST?.trim();
+    if (!raw)
+        return null;
+    return new Set(raw
+        .split(",")
+        .map((h) => h.trim().toLowerCase())
+        .filter(Boolean));
+}
+function isPrivateIpv4(host) {
+    const parts = host.split(".").map((p) => Number(p));
+    if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n) || n < 0 || n > 255)) {
+        return false;
+    }
+    const [a, b] = parts;
+    if (a === 10)
+        return true;
+    if (a === 127)
+        return true;
+    if (a === 0)
+        return true;
+    if (a === 169 && b === 254)
+        return true;
+    if (a === 172 && b >= 16 && b <= 31)
+        return true;
+    if (a === 192 && b === 168)
+        return true;
+    return false;
+}
+export function isPrivateHost(hostname) {
+    const host = hostname.toLowerCase().replace(/\.$/, "");
+    if (host === "localhost" || host.endsWith(".local") || host.endsWith(".internal")) {
+        return true;
+    }
+    if (host === "::1" || host === "0:0:0:0:0:0:0:1") {
+        return true;
+    }
+    const ipVersion = isIP(host);
+    if (ipVersion === 4) {
+        return isPrivateIpv4(host);
+    }
+    if (ipVersion === 6) {
+        const h = host.toLowerCase();
+        if (h.startsWith("fc") || h.startsWith("fd") || h.startsWith("fe80")) {
+            return true;
+        }
+    }
+    return false;
+}
+export function validateFetchUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return { ok: false, error: "Invalid URL" };
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        return { ok: false, error: "Only http(s) URLs allowed" };
+    }
+    if (isPrivateHost(parsed.hostname)) {
+        return { ok: false, error: "Private/local URLs blocked" };
+    }
+    const allowlist = getFetchUrlAllowlist();
+    if (allowlist && !allowlist.has(parsed.hostname.toLowerCase())) {
+        return { ok: false, error: `Host not in allowlist: ${parsed.hostname}` };
+    }
+    return { ok: true };
+}

package/dist/providers/ollama.d.ts

@@ -0,0 +1,2 @@
+export declare function createOllamaProvider(baseURL?: string): import("@ai-sdk/openai-compatible").OpenAICompatibleProvider<string, string, string, string>;
+//# sourceMappingURL=ollama.d.ts.map

package/dist/providers/ollama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../src/providers/ollama.ts"],"names":[],"mappings":"AAEA,wBAAgB,oBAAoB,CAAC,OAAO,SAA8B,gGAKzE"}

package/dist/providers/ollama.js

@@ -0,0 +1,7 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+export function createOllamaProvider(baseURL = "http://127.0.0.1:11434/v1") {
+    return createOpenAICompatible({
+        name: "ollama",
+        baseURL,
+    });
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,5 @@
+export declare function createAgentSdkProviderRegistry(): import("ai").ProviderRegistryProvider<{
+    ollama: import("@ai-sdk/openai-compatible").OpenAICompatibleProvider<string, string, string, string>;
+    openai: import("@ai-sdk/openai").OpenAIProvider;
+}, ":">;
+//# sourceMappingURL=registry.d.ts.map

package/dist/providers/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/providers/registry.ts"],"names":[],"mappings":"AAIA,wBAAgB,8BAA8B;;;QAK7C"}

package/dist/providers/registry.js

@@ -0,0 +1,9 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { createProviderRegistry } from "ai";
+import { createOllamaProvider } from "./ollama";
+export function createAgentSdkProviderRegistry() {
+    return createProviderRegistry({
+        ollama: createOllamaProvider(),
+        openai: createOpenAI(),
+    });
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,14 @@
+import type { ToolSet } from "ai";
+import type { SessionStoreState } from "../lfs/types";
+import { type SkillLoaderOptions } from "./skillLoader";
+import { type McpClientOptions } from "../mcp/client";
+export type ToolRegistryResult = {
+    tools: ToolSet;
+    dispose: () => Promise<void>;
+};
+export declare function createToolRegistry(params: {
+    session: SessionStoreState;
+    mcp?: McpClientOptions;
+    skillLoader?: SkillLoaderOptions;
+}): Promise<ToolRegistryResult>;
+//# sourceMappingURL=registry.d.ts.map

package/dist/tools/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAClC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAwB,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAE5E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,OAAO,EAAE,iBAAiB,CAAC;IAC3B,GAAG,CAAC,EAAE,gBAAgB,CAAC;IACvB,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0B9B"}

package/dist/tools/registry.js

@@ -0,0 +1,26 @@
+import { createRemindTool } from "./remind";
+import { createSkillLoaderTool } from "./skillLoader";
+import { createFetchMcpClient } from "../mcp/client";
+export async function createToolRegistry(params) {
+    const tools = {
+        remind: createRemindTool(params.session),
+    };
+    const skillTool = createSkillLoaderTool(params.skillLoader);
+    if (skillTool) {
+        tools.skillLoader = skillTool;
+    }
+    let mcpClient = null;
+    if (params.mcp) {
+        mcpClient = await createFetchMcpClient(params.mcp);
+        const mcpTools = await mcpClient.tools();
+        Object.assign(tools, mcpTools);
+    }
+    return {
+        tools,
+        dispose: async () => {
+            if (mcpClient) {
+                await mcpClient.close();
+            }
+        },
+    };
+}

package/dist/tools/remind.d.ts

@@ -0,0 +1,15 @@
+import type { SessionStoreState } from "../lfs/types";
+type RemindResult = {
+    hydratedIds: string[];
+    restored: Array<{
+        id: string;
+        content: string;
+    }>;
+};
+export declare function buildLfsRemindClause(state: SessionStoreState): string | undefined;
+export declare function hydrateLfsTarget(state: SessionStoreState, target: string): RemindResult;
+export declare function createRemindTool(state: SessionStoreState): import("ai").Tool<{
+    target: string;
+}, RemindResult>;
+export {};
+//# sourceMappingURL=remind.d.ts.map

package/dist/tools/remind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remind.d.ts","sourceRoot":"","sources":["../../src/tools/remind.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEtD,KAAK,YAAY,GAAG;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClD,CAAC;AAWF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,SAAS,CAQjF;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,CAyBvF;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;iBAQxD"}

package/dist/tools/remind.js

@@ -0,0 +1,53 @@
+import { tool } from "ai";
+import { z } from "zod";
+function isChunkMatch(chunkId, messageIdOrChunkId, parentMessageId) {
+    return (chunkId === messageIdOrChunkId ||
+        chunkId.startsWith(`${messageIdOrChunkId}_`) ||
+        parentMessageId === messageIdOrChunkId ||
+        parentMessageId.startsWith(`${messageIdOrChunkId}_`));
+}
+export function buildLfsRemindClause(state) {
+    const hasArchived = Object.values(state.longTermMemory).some((chunk) => chunk.isArchived);
+    if (!hasArchived)
+        return undefined;
+    return [
+        "REMIND TOOL (LFS): Archived context appears as attenuated placeholders.",
+        "Call remind with chunkId or messageId to hydrate exact raw text.",
+        "Hydrate only what is needed for the current turn.",
+    ].join(" ");
+}
+export function hydrateLfsTarget(state, target) {
+    const hydratedIds = [];
+    const restored = [];
+    for (const [chunkId, chunk] of Object.entries(state.longTermMemory)) {
+        if (!isChunkMatch(chunkId, target, chunk.parentMessageId))
+            continue;
+        chunk.isArchived = false;
+        chunk.forgetScore = 0;
+        hydratedIds.push(chunkId);
+        restored.push({ id: chunkId, content: chunk.content });
+        delete state.longTermMemory[chunkId];
+    }
+    for (const msg of state.fullHistory) {
+        if (!msg.chunks)
+            continue;
+        for (const chunk of msg.chunks) {
+            if (!isChunkMatch(chunk.chunkId, target, chunk.parentMessageId))
+                continue;
+            chunk.isArchived = false;
+            chunk.forgetScore = 0;
+            hydratedIds.push(chunk.chunkId);
+            restored.push({ id: chunk.chunkId, content: chunk.content });
+        }
+    }
+    return { hydratedIds: [...new Set(hydratedIds)], restored };
+}
+export function createRemindTool(state) {
+    return tool({
+        description: "Restore archived LFS chunk(s) by chunkId or messageId.",
+        inputSchema: z.object({
+            target: z.string().min(1).describe("chunkId or messageId to hydrate"),
+        }),
+        execute: async ({ target }) => hydrateLfsTarget(state, target),
+    });
+}

package/dist/tools/skillLoader.d.ts

@@ -0,0 +1,12 @@
+export type SkillLoaderOptions = {
+    allowedRoots: string[];
+};
+export declare function resolveSkillPath(rawPath: string, allowedRoots: string[]): string;
+export declare function loadSkillMarkdown(skillPath: string, allowedRoots: string[]): Promise<string>;
+export declare function createSkillLoaderTool(options?: SkillLoaderOptions): import("ai").Tool<{
+    path: string;
+}, {
+    path: string;
+    content: string;
+}> | null;
+//# sourceMappingURL=skillLoader.d.ts.map

package/dist/tools/skillLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillLoader.d.ts","sourceRoot":"","sources":["../../src/tools/skillLoader.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAQF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,MAAM,CAQhF;AAED,wBAAsB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAGlG;AAED,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,kBAAkB;;;;;UAiBjE"}

package/dist/tools/skillLoader.js

@@ -0,0 +1,38 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { tool } from "ai";
+import { z } from "zod";
+function isPathUnderRoot(resolved, root) {
+    const normalizedRoot = path.resolve(root);
+    const relative = path.relative(normalizedRoot, resolved);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+export function resolveSkillPath(rawPath, allowedRoots) {
+    const resolved = path.resolve(rawPath);
+    for (const root of allowedRoots) {
+        if (isPathUnderRoot(resolved, root)) {
+            return resolved;
+        }
+    }
+    throw new Error(`Skill path not under allowed roots: ${rawPath}`);
+}
+export async function loadSkillMarkdown(skillPath, allowedRoots) {
+    const resolved = resolveSkillPath(skillPath, allowedRoots);
+    return readFile(resolved, "utf8");
+}
+export function createSkillLoaderTool(options) {
+    if (!options?.allowedRoots?.length) {
+        return null;
+    }
+    const allowedRoots = options.allowedRoots;
+    return tool({
+        description: "Load a SKILL.md file from disk (paths must be under configured skill roots)",
+        inputSchema: z.object({
+            path: z.string().min(1).describe("Path to SKILL.md under an allowed root"),
+        }),
+        execute: async ({ path: skillPath }) => {
+            const content = await loadSkillMarkdown(skillPath, allowedRoots);
+            return { path: skillPath, content };
+        },
+    });
+}