mixdog 1.4.1 → 1.4.3

package/src/runtime/web-search/index.mjs

@@ -28,7 +28,6 @@ const webSearchArgsSchema = z.object({
     .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
     .describe('Search query string or array of queries.'),
   site: z.string().optional().describe('Restrict results to a specific domain.'),
-  type: z.enum(['web', 'news', 'images']).optional().describe('Search type. Default: web.'),
   maxResults: z.number().int().min(1).max(20).optional().describe('Maximum number of results to return (1-20).'),
   locale: z
     .union([
@@ -65,7 +64,7 @@ const urlArgsSchema = z.object({
   cwd: z.string().optional(),
 });
 
-const WEB_SEARCH_EMPTY_STRING_FIELDS = ['keywords', 'site', 'type', 'locale', 'contextSize'];
+const WEB_SEARCH_EMPTY_STRING_FIELDS = ['keywords', 'site', 'locale', 'contextSize'];
 
 function normalizeWebSearchArgs(rawArgs) {
   if (!rawArgs || typeof rawArgs !== 'object' || Array.isArray(rawArgs)) return rawArgs;
@@ -102,7 +101,7 @@ function normalizeUrlArgs(rawArgs) {
 function invalidArgsResponse(error) {
   if (!(error instanceof z.ZodError)) return null;
   return {
-    content: [{ type: 'text', text: JSON.stringify({ error: 'Invalid arguments', details: error.errors }) }],
+    content: [{ type: 'text', text: JSON.stringify({ error: 'Invalid arguments', details: error.issues }) }],
     isError: true,
   };
 }
@@ -153,17 +152,7 @@ function dropInvalidWebSearchResults(payload) {
   };
 }
 
-function getWebSearchCacheTtlMs(type = 'web') {
-  switch (type) {
-    case 'news':
-      return 20 * 60 * 1000;
-    case 'images':
-      return 60 * 60 * 1000;
-    // 'web' and any unknown type.
-    default:
-      return 30 * 60 * 1000;
-  }
-}
+const WEB_SEARCH_CACHE_TTL_MS = 30 * 60 * 1000;
 
 const SCRAPE_CACHE_TTL_MS = 60 * 60 * 1000;
 
@@ -207,7 +196,6 @@ function webSearchArgsForCacheKey(args) {
   return {
     keywords,
     site: args.site || null,
-    type: args.type || 'web',
     locale: args.locale || null,
     contextSize: args.contextSize || 'low',
     maxResults: clampMaxResults(args.maxResults),
@@ -222,7 +210,6 @@ function buildAgentWebSearchPrompt(args) {
     '',
     `Query: ${query}`,
     args.site ? `Site/domain restriction: ${args.site}` : null,
-    args.type ? `Search type: ${args.type}` : null,
     args.locale ? `Locale: ${localeLabel}` : null,
     `Max results: ${clampMaxResults(args.maxResults)}`,
     '',
@@ -326,7 +313,6 @@ function normalizeNativeWebSearchPayload(result, args, startedAt) {
       usage: result?.usage || null,
       results,
       warnings,
-      type: cacheArgs.type,
       site: cacheArgs.site,
       locale: cacheArgs.locale,
     },
@@ -360,12 +346,7 @@ async function _webSearchCore(args, { cacheState, nativeWebSearch, signal }) {
         signal: controller.signal,
       });
       const payload = normalizeNativeWebSearchPayload(result, { ...args, ...cacheArgs }, startedAt);
-      const cachedEntry = setCachedEntry(
-        cacheState,
-        webSearchCacheKey,
-        payload,
-        getWebSearchCacheTtlMs(cacheArgs.type)
-      );
+      const cachedEntry = setCachedEntry(cacheState, webSearchCacheKey, payload, WEB_SEARCH_CACHE_TTL_MS);
       flushCacheState();
       return { ...payload, cache: buildCacheMeta(cachedEntry, false) };
     }

package/src/runtime/web-search/lib/web-tools.mjs

@@ -67,8 +67,8 @@ function _notifyPoolWaiter() {
 
 async function _acquirePoolSlot(signal) {
   const abortError = () => signal?.reason || new Error('aborted');
-  // Waiting for a pool slot used to be uncancellable: an aborted tool call kept
-  // queueing until a slot freed, then launched a page nobody was waiting for.
+  // Waiting for a pool slot is cancellable: otherwise an aborted tool call keeps
+  // queueing until a slot frees, then launches a page nobody was waiting for.
   while (_poolActive >= PUPPETEER_POOL_MAX_PAGES) {
     if (signal?.aborted) throw abortError();
     await new Promise((resolve, reject) => {

package/src/runtime/web-search/tool-defs.mjs

@@ -1,5 +1,8 @@
-import { TOOL_SYNC_EXECUTION_CONTRACT } from '../shared/tool-execution-contract.mjs';
-
+// Model-facing text is kept minimal: every constraint dropped from these schemas
+// (minLength, pattern, minItems, maxItems, format) is enforced by the zod
+// schemas in index.mjs, which trim blanks and reject empty or non-URL input.
+// `trigger` shows only in the deferred listing, so `description` carries the
+// when-to-use guidance itself.
 const TOOL_DEFS_PLACEHOLDER = Symbol('web-fetch-schema');
 
 export const TOOL_DEFS = [
@@ -7,21 +10,18 @@ export const TOOL_DEFS = [
     name: 'web_search',
     title: 'Mixdog Web Search',
     trigger: 'Unfamiliar names, products, models, recent or external facts; search before answering from memory.',
-    description: `Cached web/docs/current-info search; batch queries sharing filters. ${TOOL_SYNC_EXECUTION_CONTRACT}`,
+    description:
+      'Search the web for recent, external or unfamiliar facts (names, products, models) before answering from memory.',
     inputSchema: {
       type: 'object',
       properties: {
         query: {
-          anyOf: [
-            { type: 'string', minLength: 1, pattern: '\\S' },
-            { type: 'array', minItems: 1, items: { type: 'string', minLength: 1, pattern: '\\S' } },
-          ],
-          description: 'Non-empty query or array for lossless fan-out.',
+          anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+          description: 'One query, or an array run as a batch.',
         },
-        site: { type: 'string', description: 'Site/domain filter.' },
-        type: { type: 'string', enum: ['web', 'news', 'images'], description: 'Default web.' },
-        maxResults: { type: 'integer', minimum: 1, maximum: 20, description: 'Result count; default 10; 1-20.' },
-        locale: { type: 'string', description: 'Optional locale hint, e.g. ko-KR or a city/region name.' },
+        site: { type: 'string', description: 'Domain filter.' },
+        maxResults: { type: 'integer', minimum: 1, maximum: 20, description: 'Default 10.' },
+        locale: { type: 'string', description: 'e.g. ko-KR.' },
         contextSize: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Default low.' },
       },
       required: ['query'],
@@ -39,25 +39,16 @@ export const TOOL_DEFS = [
     name: 'web_fetch',
     title: 'Mixdog Web Fetch',
     trigger: 'Page or docs body from a known URL; not discovery (web_search).',
-    description: 'Fetch page/docs body from URL; batch known URLs with shared slice options.',
+    description: 'Fetch the page or docs body of known URLs; to find pages, use web_search.',
     inputSchema: {
       type: 'object',
       properties: {
         url: {
-          anyOf: [
-            { type: 'string', format: 'uri' },
-            { type: 'array', items: { type: 'string', format: 'uri' }, minItems: 1, maxItems: 10 },
-          ],
-          description:
-            'Public or loopback HTTP(S) URL, or an array of up to 10; keep loopback and public URLs in separate calls.',
-        },
-        startIndex: { type: 'integer', minimum: 0, description: 'Character offset; default 0.' },
-        maxLength: {
-          type: 'integer',
-          minimum: 0,
-          description:
-            'Maximum characters; default 20000; 0 unlimited. A cut page ends with [output capped …; startIndex:N for more].',
+          anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }],
+          description: 'URL, or an array of up to 10; loopback and public URLs in separate calls.',
         },
+        startIndex: { type: 'integer', minimum: 0, description: 'Character offset.' },
+        maxLength: { type: 'integer', minimum: 0, description: 'Default 20000; 0 unlimited.' },
       },
       required: ['url'],
       additionalProperties: false,

package/src/session-runtime/agent-profile-changes.mjs

@@ -14,6 +14,18 @@ export function subscribeAgentProfileChanges(listener) {
   return { unsubscribe: () => listeners.delete(listener) };
 }
 
+/** The keys of a saved agent route its chats and reused workers follow. */
+export const AGENT_ROUTE_KEYS = Object.freeze([
+  'provider',
+  'model',
+  'effort',
+  'fast',
+  'autoEffort',
+  'modelParameters',
+  'contextPercent',
+  'contextTokens',
+]);
+
 // A bot's saved model route: the hosts of its chats (the session service)
 // move them onto it from their next turn.
 const routeListeners = new Set();
@@ -23,11 +35,50 @@ export function subscribeAgentRouteChanges(listener) {
   return { unsubscribe: () => routeListeners.delete(listener) };
 }
 
-/** Settles once every host has taken the route; one failing host never fails the save. */
-export async function publishAgentRouteChange(agentId, route) {
-  await Promise.allSettled(
+// Per bot, the route every host of this process took last (recorded only once
+// all of them took it), and the publication in flight.
+const publishedRoutes = new Map();
+const publishingRoutes = new Map();
+
+/** Every host takes the route; rejects with the hosts' failures. A
+ *  publication of the same route already in flight is joined, not repeated. */
+function deliverAgentRoute(agentId, route) {
+  const key = JSON.stringify(route ?? null);
+  const inFlight = publishingRoutes.get(agentId);
+  if (inFlight?.key === key) return inFlight.done;
+  const done = Promise.allSettled(
     [...routeListeners].map((listener) => Promise.resolve().then(() => listener(agentId, route)))
-  );
+  ).then((results) => {
+    if (publishingRoutes.get(agentId)?.done === done) publishingRoutes.delete(agentId);
+    const failures = results.filter((one) => one.status === 'rejected').map((one) => one.reason);
+    if (failures.length) {
+      throw new AggregateError(
+        failures,
+        `the ${agentId} route reached ${results.length - failures.length} of ${results.length} hosts`
+      );
+    }
+    publishedRoutes.set(agentId, key);
+  });
+  publishingRoutes.set(agentId, { key, done });
+  return done;
+}
+
+/** Settles once every host has taken the route; one failing host never fails
+ *  the save (the change step that follows it publishes the route again). */
+export async function publishAgentRouteChange(agentId, route) {
+  try {
+    await deliverAgentRoute(agentId, route);
+  } catch {}
+}
+
+/** A bot route read from a changed config (saved by another process, edited
+ *  by hand, or this process's own save): every runtime of the process applies
+ *  the same change, so the hosts hear each route once, unless one failed to
+ *  take it. Rejects when a host failed, so the change step retries it. */
+export function publishStoredAgentRoute(agentId, route) {
+  const inFlight = publishingRoutes.get(agentId);
+  if (!inFlight && publishedRoutes.get(agentId) === JSON.stringify(route ?? null)) return Promise.resolve();
+  return deliverAgentRoute(agentId, route);
 }
 
 /** Settles once every runtime has applied the edit; one failing runtime never fails the save. */