@genesislcap/ai-assistant 15.9.0 → 15.10.0

package/dist/chat-driver.mjs

@@ -1,4 +1,15 @@
 // ../../../../node_modules/tslib/tslib.es6.mjs
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -1055,6 +1066,188 @@ function scaleTemperature(normalized, { defaultTemp, maxTemp }) {
   return t <= DEFAULT_ANCHOR ? t / DEFAULT_ANCHOR * defaultTemp : defaultTemp + (t - DEFAULT_ANCHOR) / (1 - DEFAULT_ANCHOR) * (maxTemp - defaultTemp);
 }
 
+// ../../foundation-ai/dist/esm/utils/tool-schema.js
+var SCHEMA_MAP_KEYS = ["properties", "patternProperties", "$defs", "definitions"];
+var SCHEMA_LIST_KEYS = ["anyOf", "oneOf", "allOf", "prefixItems"];
+var SCHEMA_VALUE_KEYS = [
+  "items",
+  "not",
+  "additionalProperties",
+  "propertyNames",
+  "contains"
+];
+var isPlainObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function cloneValue(value) {
+  if (Array.isArray(value))
+    return value.map(cloneValue);
+  if (isPlainObject2(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value))
+      out[k] = cloneValue(v);
+    return out;
+  }
+  return value;
+}
+function mapChildSchemas(node, visit, path) {
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    const here = `${path}/${key}`;
+    if (SCHEMA_MAP_KEYS.includes(key) && isPlainObject2(value)) {
+      out[key] = Object.fromEntries(Object.entries(value).map(([name, child]) => [
+        name,
+        isPlainObject2(child) ? visit(child, `${here}/${name}`) : cloneValue(child)
+      ]));
+    } else if (SCHEMA_LIST_KEYS.includes(key) && Array.isArray(value)) {
+      out[key] = value.map((child, i) => isPlainObject2(child) ? visit(child, `${here}/${i}`) : cloneValue(child));
+    } else if (SCHEMA_VALUE_KEYS.includes(key)) {
+      if (isPlainObject2(value))
+        out[key] = visit(value, here);
+      else if (Array.isArray(value))
+        out[key] = value.map((child, i) => isPlainObject2(child) ? visit(child, `${here}/${i}`) : cloneValue(child));
+      else
+        out[key] = cloneValue(value);
+    } else {
+      out[key] = cloneValue(value);
+    }
+  }
+  return out;
+}
+function mapSchema(node, transform, path = "") {
+  return transform(mapChildSchemas(node, (child, childPath) => mapSchema(child, transform, childPath), path), path);
+}
+var UNENFORCEABLE_KEYWORDS = [
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "maxItems",
+  "uniqueItems",
+  "minProperties",
+  "maxProperties"
+];
+var UNDROPPABLE_KEYWORDS = ["oneOf", "not"];
+function toEnforcedAnthropicSchema(parameters) {
+  const stripped = [];
+  const overridden = [];
+  const undroppable = [];
+  const schema = mapSchema(parameters, (node, path) => {
+    for (const keyword of UNENFORCEABLE_KEYWORDS) {
+      if (keyword in node) {
+        delete node[keyword];
+        stripped.push(`${path}/${keyword}`);
+      }
+    }
+    if (typeof node.minItems === "number" && node.minItems > 1) {
+      delete node.minItems;
+      stripped.push(`${path}/minItems`);
+    }
+    for (const keyword of UNDROPPABLE_KEYWORDS) {
+      if (keyword in node)
+        undroppable.push(`${path}/${keyword}`);
+    }
+    const isObjectNode = node.type === "object" || Array.isArray(node.type) && node.type.includes("object") || isPlainObject2(node.properties);
+    if (isObjectNode) {
+      if (node.additionalProperties !== false) {
+        if (node.additionalProperties !== void 0) {
+          overridden.push(`${path}/additionalProperties`);
+        }
+        node.additionalProperties = false;
+      }
+    }
+    return node;
+  });
+  return { schema, stripped, overridden, undroppable };
+}
+function enforceAnthropicToolSchema(parameters, toolName) {
+  const { schema, stripped, overridden, undroppable } = toEnforcedAnthropicSchema(parameters);
+  if (stripped.length) {
+    logger.warn(`AnthropicTransport: tool "${toolName}" requested schema enforcement; these keywords cannot be enforced and were removed \u2014 validate them yourself: ${stripped.join(", ")}`);
+  }
+  if (overridden.length) {
+    logger.warn(`AnthropicTransport: tool "${toolName}" requested schema enforcement, which requires closed objects; \`additionalProperties\` was set to false at: ${overridden.join(", ")}. The tool now accepts fewer inputs than its schema declared.`);
+  }
+  if (undroppable.length) {
+    logger.warn(`AnthropicTransport: tool "${toolName}" uses schema keywords enforcement cannot express (${undroppable.join(", ")}). They cannot be removed without changing the schema's meaning, so the request will be rejected. Rewrite them or drop enforceSchema for this tool.`);
+  }
+  return schema;
+}
+var GEMINI_UNSUPPORTED_KEYWORDS = [
+  "additionalProperties",
+  "examples",
+  "multipleOf",
+  "patternProperties",
+  // Both spellings of the definitions block. `$defs` would also fall to the
+  // `$`-prefix sweep below, but the draft-07 spelling has no `$` and would
+  // otherwise survive inlining and 400 the request — so list the pair together.
+  "$defs",
+  "definitions"
+];
+function resolvePointer(root, ref) {
+  if (!ref.startsWith("#/"))
+    return void 0;
+  let current = root;
+  for (const segment of ref.slice(2).split("/")) {
+    if (!isPlainObject2(current))
+      return void 0;
+    current = current[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+  }
+  return isPlainObject2(current) ? current : void 0;
+}
+function inlineRefs(root, node, seen, unresolved) {
+  let current = node;
+  let visited = seen;
+  let ref = typeof current.$ref === "string" ? current.$ref : void 0;
+  while (ref && !visited.has(ref)) {
+    const target = resolvePointer(root, ref);
+    if (!target)
+      break;
+    const { $ref: _dropped } = current, siblings = __rest(current, ["$ref"]);
+    current = Object.assign(Object.assign({}, cloneValue(target)), siblings);
+    visited = /* @__PURE__ */ new Set([...visited, ref]);
+    ref = typeof current.$ref === "string" ? current.$ref : void 0;
+  }
+  if (typeof current.$ref === "string")
+    unresolved.push(current.$ref);
+  return mapChildSchemas(current, (child) => inlineRefs(root, child, visited, unresolved), "");
+}
+function toGeminiSchema(parameters) {
+  const unresolved = [];
+  const inlined = inlineRefs(parameters, parameters, /* @__PURE__ */ new Set(), unresolved);
+  if (unresolved.length) {
+    logger.warn(`GeminiTransport: these \`$ref\` pointers could not be inlined \u2014 a cycle, a typo, or an external ref: ${[...new Set(unresolved)].join(", ")}. They are left in the schema, so Gemini will reject this declaration; that is deliberate, because dropping them would send a node that constrains nothing.`);
+  }
+  const translated = mapSchema(inlined, (node) => {
+    if (Array.isArray(node.type)) {
+      const types = node.type.filter((t) => t !== "null");
+      if (types.length === 1 && node.type.length !== types.length) {
+        node.type = types[0];
+        node.nullable = true;
+      }
+    }
+    if (Array.isArray(node.anyOf)) {
+      const branches = node.anyOf.filter(isPlainObject2);
+      const nonNull = branches.filter((b) => b.type !== "null");
+      if (branches.length === 2 && nonNull.length === 1) {
+        const { anyOf: _dropped } = node, siblings = __rest(node, ["anyOf"]);
+        return Object.assign(Object.assign(Object.assign({}, nonNull[0]), siblings), { nullable: true });
+      }
+    }
+    if ("const" in node) {
+      node.enum = [node.const];
+      delete node.const;
+    }
+    for (const keyword of GEMINI_UNSUPPORTED_KEYWORDS)
+      delete node[keyword];
+    for (const key of Object.keys(node)) {
+      if (key.startsWith("$") && key !== "$ref")
+        delete node[key];
+    }
+    return node;
+  });
+  return translated;
+}
+
 // ../../foundation-ai/dist/esm/utils/abort-reason.js
 function authoritativeAbortReason(error, timeoutSignal, callerSignal) {
   const abortShaped = (error instanceof DOMException || error instanceof Error) && (error.name === "AbortError" || error.name === "TimeoutError");
@@ -1405,11 +1598,7 @@ var AnthropicTransport = class _AnthropicTransport {
       if (options === null || options === void 0 ? void 0 : options.systemPrompt)
         body.system = options.systemPrompt;
       if ((_a = options === null || options === void 0 ? void 0 : options.tools) === null || _a === void 0 ? void 0 : _a.length) {
-        body.tools = options.tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          input_schema: t.parameters
-        }));
+        body.tools = options.tools.map((t) => Object.assign({ name: t.name, description: t.description, input_schema: t.enforceSchema ? enforceAnthropicToolSchema(t.parameters, t.name) : t.parameters }, t.enforceSchema ? { strict: true } : {}));
       }
       if ((_b = body.tools) === null || _b === void 0 ? void 0 : _b.length) {
         const toolChoice = toAnthropicToolChoice(options === null || options === void 0 ? void 0 : options.toolChoice);
@@ -2059,7 +2248,7 @@ var GeminiTransport = class _GeminiTransport {
           functionDeclarations: options.tools.map((t) => ({
             name: t.name,
             description: t.description,
-            parameters: t.parameters
+            parameters: toGeminiSchema(t.parameters)
           }))
         }
       ] : void 0;
@@ -2082,7 +2271,7 @@ var GeminiTransport = class _GeminiTransport {
         systemInstruction,
         toolConfig,
         generationConfig
-      }, applyResponseSchema ? { responseSchema: options.responseSchema } : {}), options === null || options === void 0 ? void 0 : options.signal);
+      }, applyResponseSchema ? { responseSchema: toGeminiSchema(options.responseSchema) } : {}), options === null || options === void 0 ? void 0 : options.signal);
       return this.fromGeminiResponse(response, offeredToolNames);
     });
   }