@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/agents/schema/clean-for-gemini.js

@@ -26,18 +26,28 @@ export const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = new Set([
     "minProperties",
     "maxProperties",
 ]);
+const SCHEMA_META_KEYS = ["description", "title", "default"];
+function copySchemaMeta(from, to) {
+    for (const key of SCHEMA_META_KEYS) {
+        if (key in from && from[key] !== undefined) {
+            to[key] = from[key];
+        }
+    }
+}
 // Check if an anyOf/oneOf array contains only literal values that can be flattened.
 // TypeBox Type.Literal generates { const: "value", type: "string" }.
 // Some schemas may use { enum: ["value"], type: "string" }.
 // Both patterns are flattened to { type: "string", enum: ["a", "b", ...] }.
 function tryFlattenLiteralAnyOf(variants) {
-    if (variants.length === 0)
+    if (variants.length === 0) {
         return null;
+    }
     const allValues = [];
     let commonType = null;
     for (const variant of variants) {
-        if (!variant || typeof variant !== "object")
+        if (!variant || typeof variant !== "object") {
             return null;
+        }
         const v = variant;
         let literalValue;
         if ("const" in v) {
@@ -50,16 +60,20 @@ function tryFlattenLiteralAnyOf(variants) {
             return null;
         }
         const variantType = typeof v.type === "string" ? v.type : null;
-        if (!variantType)
+        if (!variantType) {
             return null;
-        if (commonType === null)
+        }
+        if (commonType === null) {
             commonType = variantType;
-        else if (commonType !== variantType)
+        }
+        else if (commonType !== variantType) {
             return null;
+        }
         allValues.push(literalValue);
     }
-    if (commonType && allValues.length > 0)
+    if (commonType && allValues.length > 0) {
         return { type: commonType, enum: allValues };
+    }
     return null;
 }
 function isNullSchema(variant) {
@@ -67,22 +81,25 @@ function isNullSchema(variant) {
         return false;
     }
     const record = variant;
-    if ("const" in record && record.const === null)
+    if ("const" in record && record.const === null) {
         return true;
+    }
     if (Array.isArray(record.enum) && record.enum.length === 1) {
         return record.enum[0] === null;
     }
     const typeValue = record.type;
-    if (typeValue === "null")
+    if (typeValue === "null") {
         return true;
+    }
     if (Array.isArray(typeValue) && typeValue.length === 1 && typeValue[0] === "null") {
         return true;
     }
     return false;
 }
 function stripNullVariants(variants) {
-    if (variants.length === 0)
+    if (variants.length === 0) {
         return { variants, stripped: false };
+    }
     const nonNull = variants.filter((variant) => !isNullSchema(variant));
     return {
         variants: nonNull,
@@ -98,16 +115,19 @@ function extendSchemaDefs(defs, schema) {
         !Array.isArray(schema.definitions)
         ? schema.definitions
         : undefined;
-    if (!defsEntry && !legacyDefsEntry)
+    if (!defsEntry && !legacyDefsEntry) {
         return defs;
+    }
     const next = defs ? new Map(defs) : new Map();
     if (defsEntry) {
-        for (const [key, value] of Object.entries(defsEntry))
+        for (const [key, value] of Object.entries(defsEntry)) {
             next.set(key, value);
+        }
     }
     if (legacyDefsEntry) {
-        for (const [key, value] of Object.entries(legacyDefsEntry))
+        for (const [key, value] of Object.entries(legacyDefsEntry)) {
             next.set(key, value);
+        }
     }
     return next;
 }
@@ -115,19 +135,48 @@ function decodeJsonPointerSegment(segment) {
     return segment.replaceAll("~1", "/").replaceAll("~0", "~");
 }
 function tryResolveLocalRef(ref, defs) {
-    if (!defs)
+    if (!defs) {
         return undefined;
+    }
     const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
-    if (!match)
+    if (!match) {
         return undefined;
+    }
     const name = decodeJsonPointerSegment(match[1] ?? "");
-    if (!name)
+    if (!name) {
         return undefined;
+    }
     return defs.get(name);
 }
+function simplifyUnionVariants(params) {
+    const { obj, variants } = params;
+    const { variants: nonNullVariants, stripped } = stripNullVariants(variants);
+    const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
+    if (flattened) {
+        const result = {
+            type: flattened.type,
+            enum: flattened.enum,
+        };
+        copySchemaMeta(obj, result);
+        return { variants: nonNullVariants, simplified: result };
+    }
+    if (stripped && nonNullVariants.length === 1) {
+        const lone = nonNullVariants[0];
+        if (lone && typeof lone === "object" && !Array.isArray(lone)) {
+            const result = {
+                ...lone,
+            };
+            copySchemaMeta(obj, result);
+            return { variants: nonNullVariants, simplified: result };
+        }
+        return { variants: nonNullVariants, simplified: lone };
+    }
+    return { variants: stripped ? nonNullVariants : variants };
+}
 function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
-    if (!schema || typeof schema !== "object")
+    if (!schema || typeof schema !== "object") {
         return schema;
+    }
     if (Array.isArray(schema)) {
         return schema.map((item) => cleanSchemaForGeminiWithDefs(item, defs, refStack));
     }
@@ -135,8 +184,9 @@ function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
     const nextDefs = extendSchemaDefs(defs, obj);
     const refValue = typeof obj.$ref === "string" ? obj.$ref : undefined;
     if (refValue) {
-        if (refStack?.has(refValue))
+        if (refStack?.has(refValue)) {
             return {};
+        }
         const resolved = tryResolveLocalRef(refValue, nextDefs);
         if (resolved) {
             const nextRefStack = refStack ? new Set(refStack) : new Set();
@@ -148,17 +198,11 @@ function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
             const result = {
                 ...cleaned,
             };
-            for (const key of ["description", "title", "default"]) {
-                if (key in obj && obj[key] !== undefined)
-                    result[key] = obj[key];
-            }
+            copySchemaMeta(obj, result);
             return result;
         }
         const result = {};
-        for (const key of ["description", "title", "default"]) {
-            if (key in obj && obj[key] !== undefined)
-                result[key] = obj[key];
-        }
+        copySchemaMeta(obj, result);
         return result;
     }
     const hasAnyOf = "anyOf" in obj && Array.isArray(obj.anyOf);
@@ -170,77 +214,31 @@ function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
         ? obj.oneOf.map((variant) => cleanSchemaForGeminiWithDefs(variant, nextDefs, refStack))
         : undefined;
     if (hasAnyOf) {
-        const { variants: nonNullVariants, stripped } = stripNullVariants(cleanedAnyOf ?? []);
-        if (stripped)
-            cleanedAnyOf = nonNullVariants;
-        const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
-        if (flattened) {
-            const result = {
-                type: flattened.type,
-                enum: flattened.enum,
-            };
-            for (const key of ["description", "title", "default"]) {
-                if (key in obj && obj[key] !== undefined)
-                    result[key] = obj[key];
-            }
-            return result;
-        }
-        if (stripped && nonNullVariants.length === 1) {
-            const lone = nonNullVariants[0];
-            if (lone && typeof lone === "object" && !Array.isArray(lone)) {
-                const result = {
-                    ...lone,
-                };
-                for (const key of ["description", "title", "default"]) {
-                    if (key in obj && obj[key] !== undefined)
-                        result[key] = obj[key];
-                }
-                return result;
-            }
-            return lone;
+        const simplified = simplifyUnionVariants({ obj, variants: cleanedAnyOf ?? [] });
+        cleanedAnyOf = simplified.variants;
+        if ("simplified" in simplified) {
+            return simplified.simplified;
         }
     }
     if (hasOneOf) {
-        const { variants: nonNullVariants, stripped } = stripNullVariants(cleanedOneOf ?? []);
-        if (stripped)
-            cleanedOneOf = nonNullVariants;
-        const flattened = tryFlattenLiteralAnyOf(nonNullVariants);
-        if (flattened) {
-            const result = {
-                type: flattened.type,
-                enum: flattened.enum,
-            };
-            for (const key of ["description", "title", "default"]) {
-                if (key in obj && obj[key] !== undefined)
-                    result[key] = obj[key];
-            }
-            return result;
-        }
-        if (stripped && nonNullVariants.length === 1) {
-            const lone = nonNullVariants[0];
-            if (lone && typeof lone === "object" && !Array.isArray(lone)) {
-                const result = {
-                    ...lone,
-                };
-                for (const key of ["description", "title", "default"]) {
-                    if (key in obj && obj[key] !== undefined)
-                        result[key] = obj[key];
-                }
-                return result;
-            }
-            return lone;
+        const simplified = simplifyUnionVariants({ obj, variants: cleanedOneOf ?? [] });
+        cleanedOneOf = simplified.variants;
+        if ("simplified" in simplified) {
+            return simplified.simplified;
         }
     }
     const cleaned = {};
     for (const [key, value] of Object.entries(obj)) {
-        if (GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS.has(key))
+        if (GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS.has(key)) {
             continue;
+        }
         if (key === "const") {
             cleaned.enum = [value];
             continue;
         }
-        if (key === "type" && (hasAnyOf || hasOneOf))
+        if (key === "type" && (hasAnyOf || hasOneOf)) {
             continue;
+        }
         if (key === "type" &&
             Array.isArray(value) &&
             value.every((entry) => typeof entry === "string")) {
@@ -283,13 +281,62 @@ function cleanSchemaForGeminiWithDefs(schema, defs, refStack) {
             cleaned[key] = value;
         }
     }
+    // Cloud Code Assist API rejects anyOf/oneOf in nested schemas even after
+    // simplifyUnionVariants runs above. Flatten remaining unions as a fallback:
+    // pick the common type or use the first variant's type so the tool
+    // declaration is accepted by Google's validation layer.
+    if (cleaned.anyOf && Array.isArray(cleaned.anyOf)) {
+        const flattened = flattenUnionFallback(cleaned, cleaned.anyOf);
+        if (flattened) {
+            return flattened;
+        }
+    }
+    if (cleaned.oneOf && Array.isArray(cleaned.oneOf)) {
+        const flattened = flattenUnionFallback(cleaned, cleaned.oneOf);
+        if (flattened) {
+            return flattened;
+        }
+    }
     return cleaned;
 }
+/**
+ * Last-resort flattening for anyOf/oneOf arrays that could not be simplified
+ * by `simplifyUnionVariants`. Picks a representative type so the schema is
+ * accepted by Google's restricted JSON Schema validation.
+ */
+function flattenUnionFallback(obj, variants) {
+    const objects = variants.filter((v) => !!v && typeof v === "object");
+    if (objects.length === 0) {
+        return undefined;
+    }
+    const types = new Set(objects.map((v) => v.type).filter(Boolean));
+    if (objects.length === 1) {
+        const merged = { ...objects[0] };
+        copySchemaMeta(obj, merged);
+        return merged;
+    }
+    if (types.size === 1) {
+        const merged = { type: Array.from(types)[0] };
+        copySchemaMeta(obj, merged);
+        return merged;
+    }
+    const first = objects[0];
+    if (first?.type) {
+        const merged = { type: first.type };
+        copySchemaMeta(obj, merged);
+        return merged;
+    }
+    const merged = {};
+    copySchemaMeta(obj, merged);
+    return merged;
+}
 export function cleanSchemaForGemini(schema) {
-    if (!schema || typeof schema !== "object")
+    if (!schema || typeof schema !== "object") {
         return schema;
-    if (Array.isArray(schema))
+    }
+    if (Array.isArray(schema)) {
         return schema.map(cleanSchemaForGemini);
+    }
     const defs = extendSchemaDefs(undefined, schema);
     return cleanSchemaForGeminiWithDefs(schema, defs, undefined);
 }

package/dist/agents/session-slug.js

@@ -103,30 +103,35 @@ function randomChoice(values, fallback) {
 }
 function createSlugBase(words = 2) {
     const parts = [randomChoice(SLUG_ADJECTIVES, "steady"), randomChoice(SLUG_NOUNS, "harbor")];
-    if (words > 2)
+    if (words > 2) {
         parts.push(randomChoice(SLUG_NOUNS, "reef"));
+    }
     return parts.join("-");
 }
 export function createSessionSlug(isTaken) {
     const isIdTaken = isTaken ?? (() => false);
     for (let attempt = 0; attempt < 12; attempt += 1) {
         const base = createSlugBase(2);
-        if (!isIdTaken(base))
+        if (!isIdTaken(base)) {
             return base;
+        }
         for (let i = 2; i <= 12; i += 1) {
             const candidate = `${base}-${i}`;
-            if (!isIdTaken(candidate))
+            if (!isIdTaken(candidate)) {
                 return candidate;
+            }
         }
     }
     for (let attempt = 0; attempt < 12; attempt += 1) {
         const base = createSlugBase(3);
-        if (!isIdTaken(base))
+        if (!isIdTaken(base)) {
             return base;
+        }
         for (let i = 2; i <= 12; i += 1) {
             const candidate = `${base}-${i}`;
-            if (!isIdTaken(candidate))
+            if (!isIdTaken(candidate)) {
                 return candidate;
+            }
         }
     }
     const fallback = `${createSlugBase(3)}-${Math.random().toString(36).slice(2, 5)}`;

package/dist/agents/session-tool-result-guard-wrapper.js

@@ -39,6 +39,7 @@ export function guardSessionManager(sessionManager, opts) {
         transformMessageForPersistence: (message) => applyInputProvenanceToUserMessage(message, opts?.inputProvenance),
         transformToolResultForPersistence: transform,
         allowSyntheticToolResults: opts?.allowSyntheticToolResults,
+        allowedToolNames: opts?.allowedToolNames,
         beforeMessageWriteHook: beforeMessageWrite,
     });
     sessionManager.flushPendingToolResults = guard.flushPendingToolResults;

package/dist/agents/session-tool-result-guard.js

@@ -111,7 +111,9 @@ export function installSessionToolResultGuard(sessionManager, opts) {
         let nextMessage = message;
         const role = message.role;
         if (role === "assistant") {
-            const sanitized = sanitizeToolCallInputs([message]);
+            const sanitized = sanitizeToolCallInputs([message], {
+                allowedToolNames: opts?.allowedToolNames,
+            });
             if (sanitized.length === 0) {
                 if (allowSyntheticToolResults && pending.size > 0) {
                     flushPendingToolResults();

package/dist/agents/session-transcript-repair.js

@@ -1,4 +1,6 @@
 import { extractToolCallsFromAssistant, extractToolResultId } from "./tool-call-id.js";
+const TOOL_CALL_NAME_MAX_CHARS = 64;
+const TOOL_CALL_NAME_RE = /^[A-Za-z0-9_-]+$/;
 function isToolCallBlock(block) {
     if (!block || typeof block !== "object") {
         return false;
@@ -18,8 +20,37 @@ function hasNonEmptyStringField(value) {
 function hasToolCallId(block) {
     return hasNonEmptyStringField(block.id);
 }
-function hasToolCallName(block) {
-    return hasNonEmptyStringField(block.name);
+function normalizeAllowedToolNames(allowedToolNames) {
+    if (!allowedToolNames) {
+        return null;
+    }
+    const normalized = new Set();
+    for (const name of allowedToolNames) {
+        if (typeof name !== "string") {
+            continue;
+        }
+        const trimmed = name.trim();
+        if (trimmed) {
+            normalized.add(trimmed.toLowerCase());
+        }
+    }
+    return normalized.size > 0 ? normalized : null;
+}
+function hasToolCallName(block, allowedToolNames) {
+    if (typeof block.name !== "string") {
+        return false;
+    }
+    const trimmed = block.name.trim();
+    if (!trimmed || trimmed !== block.name) {
+        return false;
+    }
+    if (trimmed.length > TOOL_CALL_NAME_MAX_CHARS || !TOOL_CALL_NAME_RE.test(trimmed)) {
+        return false;
+    }
+    if (!allowedToolNames) {
+        return true;
+    }
+    return allowedToolNames.has(trimmed.toLowerCase());
 }
 function makeMissingToolResult(params) {
     return {
@@ -55,11 +86,12 @@ export function stripToolResultDetails(messages) {
     }
     return touched ? out : messages;
 }
-export function repairToolCallInputs(messages) {
+export function repairToolCallInputs(messages, options) {
     let droppedToolCalls = 0;
     let droppedAssistantMessages = 0;
     let changed = false;
     const out = [];
+    const allowedToolNames = normalizeAllowedToolNames(options?.allowedToolNames);
     for (const msg of messages) {
         if (!msg || typeof msg !== "object") {
             out.push(msg);
@@ -73,7 +105,9 @@ export function repairToolCallInputs(messages) {
         let droppedInMessage = 0;
         for (const block of msg.content) {
             if (isToolCallBlock(block) &&
-                (!hasToolCallInput(block) || !hasToolCallId(block) || !hasToolCallName(block))) {
+                (!hasToolCallInput(block) ||
+                    !hasToolCallId(block) ||
+                    !hasToolCallName(block, allowedToolNames))) {
                 droppedToolCalls += 1;
                 droppedInMessage += 1;
                 changed = true;
@@ -98,8 +132,8 @@ export function repairToolCallInputs(messages) {
         droppedAssistantMessages,
     };
 }
-export function sanitizeToolCallInputs(messages) {
-    return repairToolCallInputs(messages).messages;
+export function sanitizeToolCallInputs(messages, options) {
+    return repairToolCallInputs(messages, options).messages;
 }
 export function sanitizeToolUseResultPairing(messages) {
     return repairToolUseResultPairing(messages).messages;

package/dist/agents/skills/bundled-dir.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { resolvePoolBotPackageRootSync } from "../../infra/poolbot-root.js";
 function looksLikeSkillsDir(dir) {
     try {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -25,17 +26,18 @@ function looksLikeSkillsDir(dir) {
     return false;
 }
 export function resolveBundledSkillsDir(opts = {}) {
-    const override = process.env.POOLBOT_BUNDLED_SKILLS_DIR?.trim() ||
-        process.env.CLAWDBOT_BUNDLED_SKILLS_DIR?.trim();
-    if (override)
+    const override = process.env.POOLBOT_BUNDLED_SKILLS_DIR?.trim();
+    if (override) {
         return override;
+    }
     // bun --compile: ship a sibling `skills/` next to the executable.
     try {
         const execPath = opts.execPath ?? process.execPath;
         const execDir = path.dirname(execPath);
         const sibling = path.join(execDir, "skills");
-        if (fs.existsSync(sibling))
+        if (fs.existsSync(sibling)) {
             return sibling;
+        }
     }
     catch {
         // ignore
@@ -44,7 +46,19 @@ export function resolveBundledSkillsDir(opts = {}) {
     try {
         const moduleUrl = opts.moduleUrl ?? import.meta.url;
         const moduleDir = path.dirname(fileURLToPath(moduleUrl));
-        // Walk up from this module to find the package root containing skills/
+        const argv1 = opts.argv1 ?? process.argv[1];
+        const cwd = opts.cwd ?? process.cwd();
+        const packageRoot = resolvePoolBotPackageRootSync({
+            argv1,
+            moduleUrl,
+            cwd,
+        });
+        if (packageRoot) {
+            const candidate = path.join(packageRoot, "skills");
+            if (looksLikeSkillsDir(candidate)) {
+                return candidate;
+            }
+        }
         let current = moduleDir;
         for (let depth = 0; depth < 6; depth += 1) {
             const candidate = path.join(current, "skills");