@probelabs/probe 0.6.0-rc318 → 0.6.0-rc320

package/build/agent/ProbeAgent.js

@@ -147,6 +147,77 @@ export function debugLogToolResults(toolResults) {
   }
 }
 
+function isPlainJsonSchemaObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) && !value._def;
+}
+
+function sanitizeRequiredFieldsInJsonSchema(schema) {
+  if (!isPlainJsonSchemaObject(schema)) {
+    return;
+  }
+
+  if (Array.isArray(schema.required) && isPlainJsonSchemaObject(schema.properties)) {
+    const propertyNames = new Set(Object.keys(schema.properties));
+    const filteredRequired = schema.required.filter((name) => propertyNames.has(name));
+    if (filteredRequired.length > 0) {
+      schema.required = filteredRequired;
+    } else {
+      delete schema.required;
+    }
+  }
+
+  const visitSchemaMap = (schemaMap) => {
+    if (!isPlainJsonSchemaObject(schemaMap)) return;
+    for (const childSchema of Object.values(schemaMap)) {
+      sanitizeRequiredFieldsInJsonSchema(childSchema);
+    }
+  };
+
+  visitSchemaMap(schema.properties);
+  visitSchemaMap(schema.patternProperties);
+  visitSchemaMap(schema.definitions);
+  visitSchemaMap(schema.$defs);
+  visitSchemaMap(schema.dependentSchemas);
+
+  if (isPlainJsonSchemaObject(schema.items)) {
+    sanitizeRequiredFieldsInJsonSchema(schema.items);
+  } else if (Array.isArray(schema.items)) {
+    for (const itemSchema of schema.items) {
+      sanitizeRequiredFieldsInJsonSchema(itemSchema);
+    }
+  }
+
+  for (const keyword of ['allOf', 'anyOf', 'oneOf']) {
+    if (Array.isArray(schema[keyword])) {
+      for (const childSchema of schema[keyword]) {
+        sanitizeRequiredFieldsInJsonSchema(childSchema);
+      }
+    }
+  }
+
+  if (isPlainJsonSchemaObject(schema.not)) {
+    sanitizeRequiredFieldsInJsonSchema(schema.not);
+  }
+
+  if (isPlainJsonSchemaObject(schema.additionalProperties)) {
+    sanitizeRequiredFieldsInJsonSchema(schema.additionalProperties);
+  }
+}
+
+export function sanitizeToolInputSchema(schema) {
+  if (!isPlainJsonSchemaObject(schema)) {
+    return schema;
+  }
+
+  try {
+    const clonedSchema = JSON.parse(JSON.stringify(schema));
+    sanitizeRequiredFieldsInJsonSchema(clonedSchema);
+    return clonedSchema;
+  } catch {
+    return schema;
+  }
+}
+
 /**
  * ProbeAgent class to handle AI interactions with code search capabilities
  */
@@ -1888,7 +1959,8 @@ export class ProbeAgent {
     const wrapTool = (toolName, schema, description, executeFn) => {
       // Auto-wrap plain JSON Schema objects with jsonSchema() for AI SDK 5 compatibility
       // Zod schemas have a _def property; plain objects need wrapping
-      const resolvedSchema = schema && schema._def ? schema : jsonSchema(schema);
+      const sanitizedSchema = sanitizeToolInputSchema(schema);
+      const resolvedSchema = sanitizedSchema && sanitizedSchema._def ? sanitizedSchema : jsonSchema(sanitizedSchema);
       return tool({
         description,
         inputSchema: resolvedSchema,
@@ -2090,8 +2162,9 @@ export class ProbeAgent {
       for (const [name, mcpTool] of Object.entries(mcpTools)) {
         // MCP tools have raw JSON Schema inputSchema that must be wrapped with jsonSchema()
         // for the Vercel AI SDK. Without wrapping, asSchema() misidentifies them as Zod schemas.
-        const mcpSchema = mcpTool.inputSchema || mcpTool.parameters;
-        const wrappedSchema = mcpSchema && mcpSchema._def ? mcpSchema : jsonSchema(mcpSchema || { type: 'object', properties: {} });
+        const mcpSchema = mcpTool.inputSchema || mcpTool.parameters || { type: 'object', properties: {} };
+        const sanitizedSchema = sanitizeToolInputSchema(mcpSchema);
+        const wrappedSchema = sanitizedSchema && sanitizedSchema._def ? sanitizedSchema : jsonSchema(sanitizedSchema);
         nativeTools[name] = tool({
           description: mcpTool.description || `MCP tool: ${name}`,
           inputSchema: wrappedSchema,

package/build/tools/vercel.js

@@ -719,14 +719,12 @@ export const searchTool = (options = {}) => {
 				// ── Delegate-level semantic dedup ────────────────────────────
 				// Each delegate is a full flash agent session (minutes, not seconds).
 				// Use LLM to detect semantic duplicates and suggest rewrites.
-				// Compare against ALL previous delegations (not filtered by path) because
-				// the parent model often narrows the path while asking the same concept
-				// (e.g., "dedup" at /src → "deduplicate" at /src/search.js).
 				const delegatePath = searchPath || '';
+				const samePathDelegations = previousDelegations.filter(d => d.path === delegatePath);
 
 				let effectiveQuery = searchQuery;
 
-				if (previousDelegations.length > 0) {
+				if (samePathDelegations.length > 0) {
 					const dedupProvider = options.searchDelegateProvider || process.env.PROBE_SEARCH_DELEGATE_PROVIDER || options.provider || process.env.FORCE_PROVIDER || null;
 					const dedupModelName = options.searchDelegateModel || process.env.PROBE_SEARCH_DELEGATE_MODEL || options.model || process.env.MODEL_NAME || null;
 					// Lazily create the dedup model (same provider/model as delegate)
@@ -742,8 +740,8 @@ export const searchTool = (options = {}) => {
 
 					const dedupSpanAttrs = {
 						'dedup.query': searchQuery,
-						'dedup.previous_count': String(previousDelegations.length),
-						'dedup.previous_queries': previousDelegations.map(d => d.query).join(' | '),
+						'dedup.previous_count': String(samePathDelegations.length),
+						'dedup.previous_queries': samePathDelegations.map(d => d.query).join(' | '),
 						'dedup.provider': dedupProvider || '',
 						'dedup.model': dedupModelName || '',
 						'dedup.model_available': cachedDedupModel ? 'true' : 'false',
@@ -751,7 +749,7 @@ export const searchTool = (options = {}) => {
 
 					const dedup = options.tracer?.withSpan
 						? await options.tracer.withSpan('search.delegate.dedup', async () => {
-							return await checkDelegateDedup(searchQuery, previousDelegations, cachedDedupModel, debug);
+							return await checkDelegateDedup(searchQuery, samePathDelegations, cachedDedupModel, debug);
 						}, dedupSpanAttrs, (span, result) => {
 							span.setAttributes({
 								'dedup.action': result.action,
@@ -760,14 +758,14 @@ export const searchTool = (options = {}) => {
 								'dedup.error': result.error || '',
 							});
 						})
-						: await checkDelegateDedup(searchQuery, previousDelegations, cachedDedupModel, debug);
+						: await checkDelegateDedup(searchQuery, samePathDelegations, cachedDedupModel, debug);
 
 					if (debug) {
 						console.error(`[DEDUP-LLM] Query: "${searchQuery}" → ${dedup.action}: ${dedup.reason}${dedup.rewritten ? ` → "${dedup.rewritten}"` : ''}`);
 					}
 
 					if (dedup.action === 'block') {
-						const prevQueries = previousDelegations.map(d => `"${d.query}"`).join(', ');
+						const prevQueries = samePathDelegations.map(d => `"${d.query}"`).join(', ');
 						return `DELEGATE BLOCKED: "${searchQuery}" is semantically duplicate of previous delegation(s) [${prevQueries}]. ${dedup.reason}\n\nDo NOT re-delegate the same concept. Use extract() on files already found, or synthesize your answer from existing results.`;
 					}