@oyasmi/pipiclaw 0.5.9 → 0.6.1

package/dist/settings.js

@@ -8,6 +8,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
+import * as log from "./log.js";
 const DEFAULT_COMPACTION = {
     enabled: true,
     reserveTokens: 16384,
@@ -40,18 +41,32 @@ const DEFAULT_SESSION_MEMORY = {
  */
 export class PipiclawSettingsManager {
     constructor(baseDir) {
+        this.loadErrors = [];
         this.settingsPath = join(baseDir, "settings.json");
         this.settings = this.load();
     }
     load() {
+        this.loadErrors = [];
         if (!existsSync(this.settingsPath)) {
             return {};
         }
         try {
             const content = readFileSync(this.settingsPath, "utf-8");
-            return JSON.parse(content);
+            const parsed = JSON.parse(content);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                this.loadErrors.push({
+                    scope: "global",
+                    error: new Error(`Expected a JSON object in ${this.settingsPath}`),
+                });
+                return {};
+            }
+            return parsed;
         }
-        catch {
+        catch (error) {
+            this.loadErrors.push({
+                scope: "global",
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
             return {};
         }
     }
@@ -64,12 +79,25 @@ export class PipiclawSettingsManager {
             writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2), "utf-8");
         }
         catch (error) {
-            console.error(`Warning: Could not save settings file: ${error}`);
+            log.logWarning(`Could not save settings file`, `${this.settingsPath}\n${String(error)}`);
         }
     }
     reload() {
         this.settings = this.load();
     }
+    drainErrors() {
+        const errors = this.loadErrors;
+        this.loadErrors = [];
+        return errors;
+    }
+    getDiagnostics() {
+        return this.loadErrors.map(({ error }) => ({
+            source: "settings",
+            path: this.settingsPath,
+            severity: "error",
+            message: error.message,
+        }));
+    }
     getCompactionSettings() {
         return {
             ...DEFAULT_COMPACTION,
@@ -377,7 +405,4 @@ export class PipiclawSettingsManager {
     flush() {
         return Promise.resolve();
     }
-    drainErrors() {
-        return [];
-    }
 }

package/dist/shared/config-diagnostics.d.ts

@@ -0,0 +1,7 @@
+export interface ConfigDiagnostic {
+    source: "settings" | "tools" | "security";
+    path: string;
+    severity: "warning" | "error";
+    message: string;
+}
+export declare function formatConfigDiagnostic(diagnostic: ConfigDiagnostic): string;

package/dist/shared/config-diagnostics.js

@@ -0,0 +1,3 @@
+export function formatConfigDiagnostic(diagnostic) {
+    return `${diagnostic.source}.json: ${diagnostic.message}`;
+}

package/dist/subagents/tool.d.ts

@@ -1,5 +1,6 @@
 import { type AgentEvent, type AgentMessage, type AgentTool } from "@mariozechner/pi-agent-core";
 import type { Api, Model } from "@mariozechner/pi-ai";
+import type { MemoryCandidateStore } from "../memory/candidates.js";
 import type { Executor } from "../sandbox.js";
 import type { SecurityConfig } from "../security/types.js";
 import type { PipiclawMemoryRecallSettings } from "../settings.js";
@@ -44,6 +45,7 @@ export interface SubAgentToolOptions {
     channelDir: string;
     getSubAgentDiscovery?: () => SubAgentDiscoveryResult;
     getMemoryRecallSettings?: () => PipiclawMemoryRecallSettings;
+    memoryCandidateStore?: MemoryCandidateStore;
     securityConfig?: SecurityConfig;
     webConfig?: PipiclawWebToolsConfig;
     runtimeContext: {

package/dist/subagents/tool.js

@@ -1,7 +1,6 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { convertToLlm } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { createMemoryCandidateCache } from "../memory/candidates.js";
 import { readChannelSession } from "../memory/files.js";
 import { recallRelevantMemory } from "../memory/recall.js";
 import { formatModelReference } from "../models/utils.js";
@@ -187,7 +186,7 @@ function stripRuntimeContextWrapper(renderedText) {
         .replace(/\s*<\/runtime_context>$/i, "")
         .trim();
 }
-async function buildContextualBlocks(task, config, options, currentModel, candidateCache = createMemoryCandidateCache()) {
+async function buildContextualBlocks(task, config, options, currentModel) {
     if (config.contextMode !== "contextual") {
         return [];
     }
@@ -226,7 +225,7 @@ async function buildContextualBlocks(task, config, options, currentModel, candid
         model: currentModel,
         resolveApiKey: options.resolveApiKey,
         allowedSources: ["workspace-memory", "channel-memory", "channel-history"],
-        candidateCache,
+        candidateStore: options.memoryCandidateStore,
     });
     const recalledText = stripRuntimeContextWrapper(recalled.renderedText);
     if (recalledText) {

package/dist/tools/config.d.ts

@@ -1,3 +1,4 @@
+import type { ConfigDiagnostic } from "../shared/config-diagnostics.js";
 export type WebSearchProvider = "brave" | "tavily" | "jina" | "searxng" | "duckduckgo";
 export interface PipiclawWebSearchConfig {
     provider: WebSearchProvider;
@@ -10,6 +11,7 @@ export interface PipiclawWebFetchConfig {
     maxChars: number;
     timeoutMs: number;
     maxImageBytes: number;
+    maxResponseBytes: number;
     preferJina: boolean;
     enableJinaFallback: boolean;
     defaultExtractMode: "markdown" | "text";
@@ -25,6 +27,11 @@ export interface PipiclawToolsConfig {
         web: PipiclawWebToolsConfig;
     };
 }
+export interface LoadedToolsConfig {
+    config: PipiclawToolsConfig;
+    diagnostics: ConfigDiagnostic[];
+}
 export declare const DEFAULT_TOOLS_CONFIG: PipiclawToolsConfig;
 export declare function getToolsConfigPath(appHomeDir?: string): string;
+export declare function loadToolsConfigWithDiagnostics(appHomeDir?: string): LoadedToolsConfig;
 export declare function loadToolsConfig(appHomeDir?: string): PipiclawToolsConfig;

package/dist/tools/config.js

@@ -19,6 +19,7 @@ export const DEFAULT_TOOLS_CONFIG = {
                 maxChars: 50_000,
                 timeoutMs: 30_000,
                 maxImageBytes: 10 * 1024 * 1024,
+                maxResponseBytes: 5 * 1024 * 1024,
                 preferJina: false,
                 enableJinaFallback: false,
                 defaultExtractMode: "markdown",
@@ -52,8 +53,17 @@ function asOptionalProxy(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
-function mergeToolsConfig(source) {
+function pushInvalidValueDiagnostic(diagnostics, configPath, field, message) {
+    diagnostics.push({
+        source: "tools",
+        path: configPath,
+        severity: "warning",
+        message: `${field}: ${message}`,
+    });
+}
+function mergeToolsConfig(source, configPath, diagnostics) {
     if (!isRecord(source)) {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "root", "expected a JSON object; using defaults");
         return DEFAULT_TOOLS_CONFIG;
     }
     const tools = isRecord(source.tools) ? source.tools : {};
@@ -63,8 +73,37 @@ function mergeToolsConfig(source) {
     const providerValue = asTrimmedString(search.provider, DEFAULT_TOOLS_CONFIG.tools.web.search.provider).toLowerCase();
     const provider = WEB_SEARCH_PROVIDERS.includes(providerValue)
         ? providerValue
-        : DEFAULT_TOOLS_CONFIG.tools.web.search.provider;
+        : (() => {
+            if (search.provider !== undefined) {
+                pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.search.provider", `unknown provider "${String(search.provider)}"; using ${DEFAULT_TOOLS_CONFIG.tools.web.search.provider}`);
+            }
+            return DEFAULT_TOOLS_CONFIG.tools.web.search.provider;
+        })();
     const defaultExtractMode = asTrimmedString(fetch.defaultExtractMode, DEFAULT_TOOLS_CONFIG.tools.web.fetch.defaultExtractMode);
+    if (web.proxy !== undefined && web.proxy !== null && typeof web.proxy !== "string") {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.proxy", "expected a string or null; using null");
+    }
+    if (search.maxResults !== undefined && clampInteger(search.maxResults, -1, 1, 10) === -1) {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.search.maxResults", "expected an integer between 1 and 10; using default");
+    }
+    if (search.timeoutMs !== undefined && clampInteger(search.timeoutMs, -1, 1) === -1) {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.search.timeoutMs", "expected a positive integer; using default");
+    }
+    if (fetch.maxChars !== undefined && clampInteger(fetch.maxChars, -1, 100) === -1) {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.fetch.maxChars", "expected an integer >= 100; using default");
+    }
+    if (fetch.timeoutMs !== undefined && clampInteger(fetch.timeoutMs, -1, 1) === -1) {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.fetch.timeoutMs", "expected a positive integer; using default");
+    }
+    if (fetch.maxImageBytes !== undefined && clampInteger(fetch.maxImageBytes, -1, 1) === -1) {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.fetch.maxImageBytes", "expected a positive integer; using default");
+    }
+    if (fetch.maxResponseBytes !== undefined && clampInteger(fetch.maxResponseBytes, -1, 1) === -1) {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.fetch.maxResponseBytes", "expected a positive integer; using default");
+    }
+    if (fetch.defaultExtractMode !== undefined && defaultExtractMode !== "text" && defaultExtractMode !== "markdown") {
+        pushInvalidValueDiagnostic(diagnostics, configPath, "tools.web.fetch.defaultExtractMode", `expected "markdown" or "text"; using ${DEFAULT_TOOLS_CONFIG.tools.web.fetch.defaultExtractMode}`);
+    }
     return {
         tools: {
             web: {
@@ -81,6 +120,7 @@ function mergeToolsConfig(source) {
                     maxChars: clampInteger(fetch.maxChars, DEFAULT_TOOLS_CONFIG.tools.web.fetch.maxChars, 100),
                     timeoutMs: clampInteger(fetch.timeoutMs, DEFAULT_TOOLS_CONFIG.tools.web.fetch.timeoutMs, 1),
                     maxImageBytes: clampInteger(fetch.maxImageBytes, DEFAULT_TOOLS_CONFIG.tools.web.fetch.maxImageBytes, 1),
+                    maxResponseBytes: clampInteger(fetch.maxResponseBytes, DEFAULT_TOOLS_CONFIG.tools.web.fetch.maxResponseBytes, 1),
                     preferJina: typeof fetch.preferJina === "boolean"
                         ? fetch.preferJina
                         : DEFAULT_TOOLS_CONFIG.tools.web.fetch.preferJina,
@@ -98,17 +138,33 @@ function mergeToolsConfig(source) {
 export function getToolsConfigPath(appHomeDir = APP_HOME_DIR) {
     return appHomeDir === APP_HOME_DIR ? TOOLS_CONFIG_PATH : join(appHomeDir, "tools.json");
 }
-export function loadToolsConfig(appHomeDir = APP_HOME_DIR) {
+export function loadToolsConfigWithDiagnostics(appHomeDir = APP_HOME_DIR) {
     const configPath = getToolsConfigPath(appHomeDir);
     if (!existsSync(configPath)) {
-        return DEFAULT_TOOLS_CONFIG;
+        return { config: DEFAULT_TOOLS_CONFIG, diagnostics: [] };
     }
     try {
         const raw = JSON.parse(readFileSync(configPath, "utf-8"));
-        return mergeToolsConfig(raw);
+        const diagnostics = [];
+        return {
+            config: mergeToolsConfig(raw, configPath, diagnostics),
+            diagnostics,
+        };
     }
     catch (error) {
-        console.warn(`Failed to load tools config from ${configPath}: ${error}`);
-        return DEFAULT_TOOLS_CONFIG;
+        return {
+            config: DEFAULT_TOOLS_CONFIG,
+            diagnostics: [
+                {
+                    source: "tools",
+                    path: configPath,
+                    severity: "error",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            ],
+        };
     }
 }
+export function loadToolsConfig(appHomeDir = APP_HOME_DIR) {
+    return loadToolsConfigWithDiagnostics(appHomeDir).config;
+}

package/dist/tools/index.d.ts

@@ -1,9 +1,11 @@
 import type { AgentTool } from "@mariozechner/pi-agent-core";
 import type { Api, Model } from "@mariozechner/pi-ai";
+import type { MemoryCandidateStore } from "../memory/candidates.js";
 import type { Executor, SandboxConfig } from "../sandbox.js";
 import type { SecurityConfig, SecurityRuntimeContext } from "../security/types.js";
 import type { PipiclawMemoryRecallSettings } from "../settings.js";
 import type { SubAgentDiscoveryResult } from "../subagents/discovery.js";
+import type { PipiclawToolsConfig } from "./config.js";
 export interface CreatePipiclawToolsOptions {
     executor: Executor;
     getCurrentModel: () => Model<Api>;
@@ -16,6 +18,9 @@ export interface CreatePipiclawToolsOptions {
     sandboxConfig: SandboxConfig;
     getSubAgentDiscovery: () => SubAgentDiscoveryResult;
     getMemoryRecallSettings: () => PipiclawMemoryRecallSettings;
+    memoryCandidateStore: MemoryCandidateStore;
+    securityConfig?: SecurityConfig;
+    toolsConfig?: PipiclawToolsConfig;
 }
 export interface CreatePipiclawBaseToolsOptions {
     securityConfig?: SecurityConfig;

package/dist/tools/index.js

@@ -25,8 +25,8 @@ export function createPipiclawBaseTools(executor, options = {}) {
     ];
 }
 export function createPipiclawTools(options) {
-    const securityConfig = loadSecurityConfig(APP_HOME_DIR);
-    const toolsConfig = loadToolsConfig(APP_HOME_DIR);
+    const securityConfig = options.securityConfig ?? loadSecurityConfig(APP_HOME_DIR);
+    const toolsConfig = options.toolsConfig ?? loadToolsConfig(APP_HOME_DIR);
     const securityContext = {
         workspaceDir: options.workspaceDir,
         workspacePath: options.workspacePath,
@@ -65,6 +65,7 @@ export function createPipiclawTools(options) {
             channelDir: options.channelDir,
             getSubAgentDiscovery: options.getSubAgentDiscovery,
             getMemoryRecallSettings: options.getMemoryRecallSettings,
+            memoryCandidateStore: options.memoryCandidateStore,
             securityConfig,
             webConfig: toolsConfig.tools.web,
             runtimeContext: {

package/dist/web/client.d.ts

@@ -23,6 +23,7 @@ export interface WebHttpRequestOptions {
     timeoutMs: number;
     signal?: AbortSignal;
     maxRedirects?: number;
+    maxResponseBytes?: number;
 }
 export declare class WebHttpClient {
     private readonly context;

package/dist/web/client.js

@@ -108,24 +108,36 @@ export class WebHttpClient {
                 throw error;
             }
             const agent = getProxyAgent(currentUrl, this.context.webConfig.proxy);
-            const response = await axios.request({
-                method,
-                url: currentUrl,
-                data,
-                headers: {
-                    "User-Agent": WEB_USER_AGENT,
-                    Accept: "*/*",
-                    ...options.headers,
-                },
-                responseType: "arraybuffer",
-                validateStatus: () => true,
-                timeout: options.timeoutMs,
-                signal: options.signal,
-                maxRedirects: 0,
-                proxy: false,
-                httpAgent: agent,
-                httpsAgent: agent,
-            });
+            let response;
+            try {
+                response = await axios.request({
+                    method,
+                    url: currentUrl,
+                    data,
+                    headers: {
+                        "User-Agent": WEB_USER_AGENT,
+                        Accept: "*/*",
+                        ...options.headers,
+                    },
+                    responseType: "arraybuffer",
+                    validateStatus: () => true,
+                    timeout: options.timeoutMs,
+                    signal: options.signal,
+                    maxRedirects: 0,
+                    maxContentLength: options.maxResponseBytes ?? Number.POSITIVE_INFINITY,
+                    proxy: false,
+                    httpAgent: agent,
+                    httpsAgent: agent,
+                });
+            }
+            catch (error) {
+                if (options.maxResponseBytes &&
+                    typeof error?.message === "string" &&
+                    error.message.includes("maxContentLength")) {
+                    throw new Error(`Response exceeds maxResponseBytes (${options.maxResponseBytes} bytes)`);
+                }
+                throw error;
+            }
             const headers = normalizeHeaders(response.headers);
             const body = Buffer.isBuffer(response.data) ? response.data : Buffer.from(response.data);
             if (isRedirectStatus(response.status) && headers.location) {

package/dist/web/config.d.ts

@@ -10,6 +10,7 @@ export interface ResolvedWebFetchRequest {
     maxChars: number;
     timeoutMs: number;
     maxImageBytes: number;
+    maxResponseBytes: number;
     preferJina: boolean;
     enableJinaFallback: boolean;
 }

package/dist/web/config.js

@@ -12,6 +12,7 @@ export function resolveWebFetchRequest(config, url, extractMode, maxChars) {
         maxChars: clamp(maxChars, config.maxChars, 100),
         timeoutMs: config.timeoutMs,
         maxImageBytes: config.maxImageBytes,
+        maxResponseBytes: config.maxResponseBytes,
         preferJina: config.preferJina,
         enableJinaFallback: config.enableJinaFallback,
     };

package/dist/web/fetch.d.ts

@@ -17,6 +17,7 @@ export declare function runWebFetch(context: WebFetchExecutionContext, request:
     extractMode: "markdown" | "text";
     maxChars: number;
     maxImageBytes: number;
+    maxResponseBytes: number;
     preferJina: boolean;
     enableJinaFallback: boolean;
 }, signal?: AbortSignal): Promise<WebFetchOutput>;

package/dist/web/fetch.js

@@ -22,7 +22,7 @@ function isHtmlContent(contentType, body) {
         .toLowerCase();
     return head.startsWith("<!doctype") || head.startsWith("<html");
 }
-async function tryFetchViaJina(context, url, maxChars, signal) {
+async function tryFetchViaJina(context, url, maxChars, maxResponseBytes, signal) {
     const client = createWebHttpClient({
         webConfig: context.webConfig,
         securityConfig: context.securityConfig,
@@ -37,6 +37,7 @@ async function tryFetchViaJina(context, url, maxChars, signal) {
         url: `https://r.jina.ai/${url}`,
         headers,
         timeoutMs: context.webConfig.fetch.timeoutMs,
+        maxResponseBytes,
         signal,
     });
     if (response.status < 200 || response.status >= 300 || !data.data?.content) {
@@ -59,7 +60,7 @@ async function tryFetchViaJina(context, url, maxChars, signal) {
         },
     };
 }
-async function fetchDirect(context, url, extractMode, maxChars, maxImageBytes, signal) {
+async function fetchDirect(context, url, extractMode, maxChars, maxImageBytes, maxResponseBytes, signal) {
     const client = createWebHttpClient({
         webConfig: context.webConfig,
         securityConfig: context.securityConfig,
@@ -69,6 +70,7 @@ async function fetchDirect(context, url, extractMode, maxChars, maxImageBytes, s
     const response = await client.request({
         url,
         timeoutMs: context.webConfig.fetch.timeoutMs,
+        maxResponseBytes,
         signal,
     });
     if (response.status < 200 || response.status >= 300) {
@@ -127,19 +129,19 @@ async function fetchDirect(context, url, extractMode, maxChars, maxImageBytes, s
 }
 export async function runWebFetch(context, request, signal) {
     if (request.preferJina) {
-        const jinaResult = await tryFetchViaJina(context, request.url, request.maxChars, signal);
+        const jinaResult = await tryFetchViaJina(context, request.url, request.maxChars, request.maxResponseBytes, signal);
         if (jinaResult) {
             return jinaResult;
         }
     }
     try {
-        return await fetchDirect(context, request.url, request.extractMode, request.maxChars, request.maxImageBytes, signal);
+        return await fetchDirect(context, request.url, request.extractMode, request.maxChars, request.maxImageBytes, request.maxResponseBytes, signal);
     }
     catch (error) {
         if (!request.enableJinaFallback) {
             throw error;
         }
-        const jinaResult = await tryFetchViaJina(context, request.url, request.maxChars, signal);
+        const jinaResult = await tryFetchViaJina(context, request.url, request.maxChars, request.maxResponseBytes, signal);
         if (jinaResult) {
             return jinaResult;
         }

package/dist/web/search-providers.js

@@ -19,6 +19,9 @@ function normalizeResult(item) {
         snippet,
     };
 }
+function isProviderConfigStatus(status) {
+    return status === 400 || status === 401 || status === 403 || status === 422 || status === 429;
+}
 class BraveSearchProvider {
     constructor(context) {
         this.context = context;
@@ -38,7 +41,7 @@ class BraveSearchProvider {
             signal,
         });
         if (response.status < 200 || response.status >= 300) {
-            throw new WebSearchProviderError("provider", `Brave search failed with HTTP ${response.status}`);
+            throw new WebSearchProviderError(isProviderConfigStatus(response.status) ? "config" : "provider", `Brave search failed with HTTP ${response.status}`);
         }
         return (data.web?.results ?? [])
             .map((item) => normalizeResult({
@@ -71,7 +74,7 @@ class TavilySearchProvider {
             signal,
         });
         if (response.status < 200 || response.status >= 300) {
-            throw new WebSearchProviderError("provider", `Tavily search failed with HTTP ${response.status}`);
+            throw new WebSearchProviderError(isProviderConfigStatus(response.status) ? "config" : "provider", `Tavily search failed with HTTP ${response.status}`);
         }
         return (data.results ?? [])
             .map((item) => normalizeResult({
@@ -101,7 +104,7 @@ class JinaSearchProvider {
             signal,
         });
         if (response.status < 200 || response.status >= 300) {
-            throw new WebSearchProviderError("provider", `Jina search failed with HTTP ${response.status}`);
+            throw new WebSearchProviderError(isProviderConfigStatus(response.status) ? "config" : "provider", `Jina search failed with HTTP ${response.status}`);
         }
         return (data.data ?? [])
             .map((item) => normalizeResult({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oyasmi/pipiclaw",
-	"version": "0.5.9",
+	"version": "0.6.1",
 	"description": "An AI assistant runtime for coding and team workflows, with DingTalk AI Cards, sub-agents, memory, and scheduled events.",
 	"type": "module",
 	"bin": {