mixdog 1.2.6 → 1.3.1

package/src/runtime/agent/orchestrator/providers/openai-error-contract.mjs

@@ -14,14 +14,6 @@ import { retryAfterMsFromError, sleepWithAbort } from './retry-classifier.mjs';
 
 const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 
-// Explicit quota / billing refusals: waiting never helps, so no retry layer
-// may treat them as an ordinary rate limit.
-const QUOTA_OR_BILLING_CODE_RE = /quota|billing|usage_limit|usage_not_included/;
-
-export function isQuotaOrBillingCode(code) {
-  return QUOTA_OR_BILLING_CODE_RE.test(String(code || '').toLowerCase());
-}
-
 /**
  * Parse an HTTP error body ONCE into its contract fields. `message` is the
  * body's own message (untruncated); callers truncate for diagnostics.
@@ -211,7 +203,8 @@ export function applyErrorContract(err, { status, headers, code, error, event }
       err.status = n;
       err.httpStatus = n;
     }
-    const wireHeaders = headers ?? error?.headers ?? event?.error?.headers ?? event?.response?.error?.headers ?? event?.headers;
+    const wireHeaders =
+      headers ?? error?.headers ?? event?.error?.headers ?? event?.response?.error?.headers ?? event?.headers;
     if (wireHeaders && typeof wireHeaders === 'object') err.headers = wireHeaders;
     const rawCode = code ?? error?.code ?? error?.type ?? null;
     if (typeof rawCode === 'string' && rawCode.trim()) err.code = rawCode.trim().toLowerCase();
@@ -225,7 +218,13 @@ export function applyErrorContract(err, { status, headers, code, error, event }
       if (err.retryAfterAt == null) err.retryAfterAt = Date.now() + retryAfterMs;
     }
     const type = typeof error?.type === 'string' ? error.type.trim().toLowerCase() : '';
-    const mapped = typedWireErrorMessage({ code: err.code || '', type, error, headers: err.headers, resetAt: err.resetAt });
+    const mapped = typedWireErrorMessage({
+      code: err.code || '',
+      type,
+      error,
+      headers: err.headers,
+      resetAt: err.resetAt,
+    });
     if (mapped) applyTypedWireMessage(err, mapped, error?.message);
   } catch {}
   return err;
@@ -238,7 +237,12 @@ export function applyErrorContract(err, { status, headers, code, error, event }
  * makes unknown codes default-retryable).
  */
 export function markContentFilter(err, reason) {
-  if (String(reason || '').trim().toLowerCase() !== 'content_filter') return err;
+  if (
+    String(reason || '')
+      .trim()
+      .toLowerCase() !== 'content_filter'
+  )
+    return err;
   err.code = 'content_filter';
   err.providerErrorCode = 'content_filter';
   return err;
@@ -260,7 +264,8 @@ export function httpResponseError({ label, status, headers, text, initialRespons
 }
 
 // The route decides the HTTP/SSE label: the api-key `openai` provider is not OAuth.
-export const httpLabel = (auth) => (auth?.type === 'openai-direct' ? 'OpenAI HTTP fallback' : 'OpenAI OAuth HTTP fallback');
+export const httpLabel = (auth) =>
+  auth?.type === 'openai-direct' ? 'OpenAI HTTP fallback' : 'OpenAI OAuth HTTP fallback';
 
 /**
  * Changing transport must not bypass the server's retry deadline.

package/src/runtime/agent/orchestrator/providers/openai-oauth-tokens.mjs

@@ -92,6 +92,15 @@ export function identityFromTokens(...tokens) {
   return normalizeAccountIdentity({ id: [sub, accountId].filter(Boolean).join(':'), email });
 }
 
+/** ChatGPT plan (e.g. plus, pro) from the first token carrying the claim, else null. */
+export function planFromTokens(...tokens) {
+  for (const token of tokens) {
+    const plan = decodeJwtPayload(token)?.['https://api.openai.com/auth']?.chatgpt_plan_type;
+    if (typeof plan === 'string' && plan) return plan;
+  }
+  return null;
+}
+
 /** mtime of the token file, 0 when it is missing or unreadable. */
 export function tokensFileMtimeMs() {
   try {
@@ -165,6 +174,7 @@ export function describeOpenAIOAuthCredentials() {
       ...oauthCredentialStatus({ hasRefresh, expiresAt, detail: source, refreshSkewMs: TOKEN_REFRESH_SKEW_MS }),
       ...accountIdentityFields(tokens.identity),
       ...(accountId ? { accountId } : {}),
+      plan: planFromTokens(tokens.id_token, tokens.access_token),
     };
   } catch (err) {
     return {

package/src/runtime/agent/orchestrator/providers/openai-responses-input.mjs

@@ -1,6 +1,7 @@
 // Transcript lowering is independent of request/turn metadata. A retained
 // message must have the same wire representation in every subsequent request.
 import { providerReplayItems } from './lib/provider-replay.mjs';
+import { OPENAI_RESPONSES_TOOL_CALL_IDS, withWireToolCallIds } from './lib/tool-call-wire-ids.mjs';
 import { responsesEffortUpdates } from './effort-configuration.mjs';
 import { ensureResponsesCallOutputs } from './lib/wire-pairing.mjs';
 import { normalizeContentForOpenAIResponses, splitToolContentForOpenAIResponses } from './media-normalization.mjs';
@@ -147,7 +148,8 @@ function pushAssistantToolCalls(toolCalls, { out, customToolCallIds, nativeSearc
  *  - `includeSystem`, `nativePdf`, `splitToolContent`, `startIndex`: the
  *    gateway's system/media/continuation handling.
  */
-export function convertMessagesToResponsesInput(messages, opts = {}) {
+export function convertMessagesToResponsesInput(transcript, opts = {}) {
+  const messages = withWireToolCallIds(transcript, OPENAI_RESPONSES_TOOL_CALL_IDS);
   const out = [];
   const pendingToolMedia = [];
   const pendingToolLoads = [];

package/src/runtime/agent/orchestrator/providers/provider-error-kind.mjs

@@ -335,8 +335,19 @@ const CODE_KINDS = new Map(
     quota_exhausted: ['quota_exceeded', 'quota_exhausted', 'usage_limit_reached', 'provider_accounts_exhausted'],
     context_overflow: ['context_length_exceeded', 'context_window_exceeded', 'model_context_window_exceeded'],
     request_too_large: ['request_too_large', 'payload_too_large', 'request_entity_too_large'],
-    auth: ['invalid_api_key', 'authentication_error', 'unauthenticated', 'unauthorized', 'invalid_authentication'],
-    permission: ['permission_error', 'permission_denied', 'forbidden'],
+    // Google names a rejected or expired key with an ErrorInfo reason on an
+    // INVALID_ARGUMENT 400; the reason outranks the envelope status.
+    auth: [
+      'invalid_api_key',
+      'authentication_error',
+      'unauthenticated',
+      'unauthorized',
+      'invalid_authentication',
+      'api_key_invalid',
+      'api_key_expired',
+      'access_token_expired',
+    ],
+    permission: ['permission_error', 'permission_denied', 'forbidden', 'service_disabled', 'api_key_service_blocked'],
     overloaded: [
       'server_is_overloaded',
       'overloaded_error',
@@ -374,6 +385,7 @@ const CODE_KINDS = new Map(
       'not_found',
       'not_found_error',
       'model_not_found',
+      'model_not_supported',
       'unsupported_parameter',
     ],
   }).flatMap(([kind, codes]) => codes.map((code) => [code, kind]))

package/src/runtime/agent/orchestrator/providers/retry-executor.mjs

@@ -150,6 +150,13 @@ function isOverloadFailure(status, errorKind) {
   return status === 529 || errorKind === 'overloaded';
 }
 
+function exceedsAdviceCeiling(caught, opts) {
+  const ceiling = Number(opts.maxRetryAfterMs);
+  if (!(ceiling > 0)) return false;
+  const advised = retryAfterMsFromError(caught);
+  return advised != null && advised > ceiling;
+}
+
 // Decides whether `caught` may be re-issued: returns the error to throw (the
 // caught one, the exhausted-marked one on the last attempt, or the model
 // fallback trigger) or null when the next attempt may run — and only then
@@ -206,6 +213,16 @@ function retryVerdict(caught, { opts, attempt, maxAttempts, state }) {
     const typedQuota = QUOTA_KINDS.has(providerErrorKind(caught, { quotaFlags: false }).kind);
     if (typedQuota || opts.retry429 === false || status !== 429) return caught;
   }
+  // Opt-in `maxRetryAfterMs`: a server wait longer than the caller will sit
+  // through is a lock-out, not a retry. It surfaces now (with its advice for
+  // the notice and the account pool) instead of parking the send for it.
+  if (exceedsAdviceCeiling(caught, opts)) {
+    return markProviderRecoveryExhausted(caught, {
+      owner: opts.recoveryOwner || 'withRetry',
+      attempts: attempt + 1,
+      terminal: true,
+    });
+  }
   // Background calls (titles and the like) never retry an overload: during a
   // capacity cascade every retry multiplies gateway load, and nobody is
   // waiting on the result.

package/src/runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs

@@ -1,3 +1,5 @@
+import { loginPageUrl } from '../session/human-gate/requests.mjs';
+
 const ASK_USER_MAX_QUESTIONS = 4;
 export const ASK_USER_MAX_TEXT = 4000;
 
@@ -50,13 +52,106 @@ export const ASK_USER_TOOL_DEFS = Object.freeze([
             required: ['question', 'header', 'options'],
           },
         },
+        handoff: {
+          type: 'object',
+          description:
+            'Instead of questions: secret = the user types a password/token into the focused field (you never see it; result provided/skipped/timeout); takeover = the user does a step (sign-in, CAPTCHA, 2FA) and says done.',
+          properties: {
+            kind: { type: 'string', enum: ['secret', 'takeover'] },
+            surface: { type: 'string', enum: ['browser', 'computer'] },
+            target: { type: 'string', maxLength: 200, description: 'Site/app and form.' },
+            field: { type: 'string', maxLength: 80, description: 'secret: field label.' },
+            instructions: { type: 'string', maxLength: 2000, description: 'takeover: what to do.' },
+            need: {
+              type: 'string',
+              enum: ['sign_in', 'action', 'confirmation'],
+              description:
+                'takeover: sign_in (sign-in, 2FA), action (CAPTCHA, other step), confirmation (identity/payment check). Default action.',
+            },
+            purpose: {
+              type: 'string',
+              enum: ['login'],
+              description: 'browser takeover: login = sign-in window on url.',
+            },
+            url: { type: 'string', maxLength: 2048, description: 'login: sign-in page (https).' },
+            tab: { type: 'string', maxLength: 64, description: 'browser takeover: page ID from list_tabs.' },
+            window_id: { type: 'string', maxLength: 128, description: 'computer takeover: exact window id.' },
+            app: { type: 'string', maxLength: 120, description: 'computer takeover: app name.' },
+          },
+          required: ['kind', 'surface'],
+          additionalProperties: false,
+        },
       },
-      required: ['questions'],
       additionalProperties: false,
     },
   },
 ]);
 
+/** The handoff of an ask_user call ({ kind, surface, target, field, instructions }), or null. */
+export function validateAskUserHandoff(args) {
+  const handoff = args?.handoff;
+  if (handoff == null) return null;
+  if (args.questions != null) throw new Error('ask_user takes questions or a handoff, not both');
+  if (typeof handoff !== 'object' || Array.isArray(handoff)) throw new Error('ask_user handoff must be an object');
+  if (handoff.kind !== 'secret' && handoff.kind !== 'takeover') {
+    throw new Error('ask_user handoff kind is secret or takeover');
+  }
+  if (handoff.surface !== 'browser' && handoff.surface !== 'computer') {
+    throw new Error('ask_user handoff surface is browser or computer');
+  }
+  const text = (key, limit) => (typeof handoff[key] === 'string' ? handoff[key].trim().slice(0, limit) : '');
+  if (handoff.kind === 'takeover' && !text('instructions', 2000)) {
+    throw new Error('ask_user takeover needs instructions');
+  }
+  const login = handoffLogin(handoff);
+  let need = login ? 'sign_in' : 'action';
+  if (['sign_in', 'action', 'confirmation'].includes(handoff.need)) need = handoff.need;
+  return {
+    kind: handoff.kind,
+    surface: handoff.surface,
+    target: text('target', 200),
+    field: text('field', 80),
+    instructions: text('instructions', 2000),
+    ...(handoff.kind === 'takeover' ? { need, identity: handoffIdentity(handoff), ...(login ? { login } : {}) } : {}),
+  };
+}
+
+/** A login takeover's sign-in page ({ url, origin }); null without the
+ *  explicit purpose, so every other takeover keeps the side panel. */
+function handoffLogin(handoff) {
+  if (handoff.purpose == null) return null;
+  if (handoff.purpose !== 'login' || handoff.kind !== 'takeover' || handoff.surface !== 'browser') {
+    throw new Error('ask_user purpose login is a browser takeover');
+  }
+  const page = loginPageUrl(handoff.url);
+  if (!page) throw new Error('ask_user login needs an https url (http only on localhost)');
+  return page;
+}
+
+/** The window a takeover is about, validated per surface: a browser page ID
+ *  (list_tabs p1, v1 or a page name) or a computer window id and app. Shapes
+ *  that are not plain tokens are dropped, never passed on. */
+const TOKEN = /^[\w.:#@-]+$/;
+function handoffIdentity(handoff) {
+  const token = (key, limit) => {
+    const value = typeof handoff[key] === 'string' ? handoff[key].trim() : '';
+    return value && value.length <= limit && TOKEN.test(value) ? value : '';
+  };
+  if (handoff.surface === 'browser') {
+    const tab = token('tab', 64);
+    return tab ? { tab } : {};
+  }
+  const windowId = token('window_id', 128);
+  const app =
+    typeof handoff.app === 'string'
+      ? handoff.app
+          .replace(/[\r\n]+/g, ' ')
+          .trim()
+          .slice(0, 120)
+      : '';
+  return { ...(windowId ? { windowId } : {}), ...(app ? { app } : {}) };
+}
+
 /** Throws a clear error when the questions are malformed; returns the list. */
 export function validateAskUserQuestions(args) {
   const questions = args?.questions;

package/src/runtime/agent/orchestrator/runtime-core/context-status-shape.mjs

@@ -46,6 +46,7 @@ export function sessionTokenCounters(session) {
     totalOutputTokens: Number(session?.totalOutputTokens || 0),
     totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
     totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+    usageReadout: session?.usageReadout || null,
     compactBoundaryTokens: Number(session?.compactBoundaryTokens || 0),
   };
 }
@@ -64,6 +65,9 @@ function sessionUsageCounters(session, lastContextTokens) {
     totalOutputTokens: Number(session?.totalOutputTokens || 0),
     totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
     totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
+    // Session-cumulative cache/speed totals behind the composer readout; null
+    // until the session has a call recorded.
+    usageReadout: session?.usageReadout || null,
   };
 }
 

package/src/runtime/agent/orchestrator/runtime-core/extension-scopes.mjs

@@ -48,12 +48,14 @@ export function filterMcpToolsForCwd(tools, scopes, cwd) {
   });
 }
 
-/** The MCP tools a session at `cwd` may see. No scopes configured → input
- *  returned as-is, so the global-only fast path costs one config read. */
+/** The MCP tools a session at `cwd` may see. No scopes configured → the input
+ *  as-is, so the global-only fast path costs one config read. An agent's
+ *  connectors never narrow this list: the schema and the BP2 manifest stay
+ *  identical across agents (one shared cache prefix), and the connector policy
+ *  is enforced at dispatch (pre-dispatch-deny / connector approval). */
 export function filterMcpToolsForSession(tools, cwd, config = null) {
   const list = Array.isArray(tools) ? tools : [];
   if (!list.length) return list;
   const scopes = extensionScopesFromConfig(config || loadConfig({ secrets: false }));
-  if (!hasExtensionScopes(scopes)) return list;
-  return filterMcpToolsForCwd(list, scopes, cwd);
+  return hasExtensionScopes(scopes) ? filterMcpToolsForCwd(list, scopes, cwd) : list;
 }

package/src/runtime/agent/orchestrator/runtime-core/orchestration.mjs

@@ -19,6 +19,20 @@ Lead executes all work directly and never delegates on its own judgment.
 Only when the user explicitly asks for delegation, load the deferred \`agent\`
 tool and brief each agent as the Lead rules describe.`;
 
+/** Agent mode's fixed delegation block, in place of the orchestration mode. */
+export const AGENT_MODE_DELEGATION = `# Delegation
+
+Handle conversation yourself. Delegate specialised work to sub-agents. Hand
+substantial coding to a new agent task session (\`session create\`) with
+a self-contained brief: start it when already requested, otherwise suggest it. Then relay the
+result in your own words. Work sent to an existing session (\`session send\`)
+reports back only when its result says reportsBack: true; promise to report
+only then.`;
+
+/** Mixy only: it also routes requests to the user's contact agents. */
+export const MIXY_CONTACTS_INTRO = `You also coordinate the user's contact agents: route a request to the
+contact best suited for it with the same kind of brief.`;
+
 export function orchestrationInstructions(value) {
   const mode = normalizeOrchestrationMode(value);
   if (mode === 'none') return SOLO;

package/src/runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs

@@ -23,6 +23,7 @@ const MCP_TRANSPORT_FIELDS = new Set([
   'env_http_headers',
   'env_vars',
   'autoDetect',
+  'oauthClientId',
 ]);
 
 // Every spelling resolveMcpStartupTimeoutMs / resolveMcpCallTimeoutMs reads.

package/src/runtime/agent/orchestrator/runtime-core/tool-bridge.mjs

@@ -14,6 +14,7 @@ import {
   deferredCatalogUnion,
   filterSessionToolPolicy,
   isReadonlySelectable,
+  mcpServerSelection,
   toolSearchMatches,
 } from './tool-catalog.mjs';
 import { parseToolSelection, sortedCatalogByMeasuredUsage } from './tool-catalog-schema.mjs';
@@ -249,8 +250,9 @@ function describeNames(raw) {
   return names;
 }
 
-// Requested names → available tools; an alias that names no tool expands to
-// its members (existing load_tool alias compatibility).
+// Requested names → available tools; an alias or `mcp__<server>` that names no
+// tool expands to its members (existing load_tool alias compatibility).
+// Definitions past the continuation target cap are listed as omitted.
 function resolveDescribeTargets(session, names, mode, available) {
   const eagerNames = eagerToolNames(session);
   const targets = [];
@@ -271,13 +273,15 @@ function resolveDescribeTargets(session, names, mode, available) {
       add(tool);
       continue;
     }
-    const members = (DEFERRED_SELECT_ALIASES[requested.toLowerCase()] || [])
+    const aliased = (DEFERRED_SELECT_ALIASES[requested.toLowerCase()] || [])
       .map((member) => lookupByName(available, member))
       .filter(Boolean);
+    const members = aliased.length ? aliased : mcpServerSelection(available, requested);
     if (members.length) members.forEach(add);
     else missing.push(requested);
   }
-  return { targets, missing, blocked };
+  const omitted = targets.splice(BRIDGE_LIMITS.continuationMaxTargets).map((tool) => clean(tool?.name));
+  return { targets, missing, blocked, omitted };
 }
 
 const SEARCH_MAX_MATCHES = 20;
@@ -367,6 +371,7 @@ export function describeBridgeTools(session, args = {}, { mode } = {}) {
   let missing = [];
   let blocked = [];
   let matches = [];
+  let omitted = [];
   if (continuation) {
     targets = continuationTargets(session, continuation.indexes, available, mode);
     if (!targets) return catalogChanged();
@@ -378,10 +383,11 @@ export function describeBridgeTools(session, args = {}, { mode } = {}) {
         `names must be 1-${BRIDGE_LIMITS.describeMaxNames} exact tool names of at most ${BRIDGE_LIMITS.nameMaxChars} characters.${syntaxHint}`
       );
     }
-    ({ targets, missing, blocked } = resolveDescribeTargets(session, names, mode, available));
+    ({ targets, missing, blocked, omitted } = resolveDescribeTargets(session, names, mode, available));
     ({ matches, missing } = searchKeywords(session, missing, mode, available));
   }
-  const found = matches.length ? { matches } : {};
+  // Omitted names are described by a later request naming them.
+  const found = { ...(matches.length ? { matches } : {}), ...(omitted.length ? { omitted } : {}) };
   const docs = targets.map((tool) => {
     const document = toolDocument(tool);
     return {

package/src/runtime/agent/orchestrator/runtime-core/tool-catalog.mjs

@@ -4,6 +4,8 @@
 import { clean } from './session-text.mjs';
 import { mergePendingDeferredToolDelta } from './deferred-tool-delta.mjs';
 import { applyInitialDeferredToolManifestToBp2 } from '../context/collect.mjs';
+import { listedDeferredToolNames } from '../context/deferred-tools.mjs';
+import { parseMcpToolName } from '../../../shared/tool-primitives.mjs';
 import { getMcpServerInstructionsMap, getMcpTools, getMcpToolGeneration } from '../mcp/client.mjs';
 import { filterMcpToolsForSession } from './extension-scopes.mjs';
 import { isDeferredToolAvailable, isToolPermittedBySessionPolicy } from './deferred-tool-availability.mjs';
@@ -259,6 +261,17 @@ function expandSelectionNames(names) {
   return [...new Set(out)];
 }
 
+/**
+ * The tools of `tools` that `mcp__<server>` stands for (the deferred manifest
+ * lists MCP servers, not their tools); [] for any other name. Callers try an
+ * exact tool name first.
+ */
+export function mcpServerSelection(tools, requested) {
+  const server = /^mcp__(.+)$/i.exec(clean(requested))?.[1]?.toLowerCase();
+  if (!server) return [];
+  return (tools || []).filter((tool) => String(parseMcpToolName(tool)?.server || '').toLowerCase() === server);
+}
+
 function storedDeferredToolNames(session) {
   for (const source of [session?.deferredDiscoveredTools, session?.deferredSelectedTools]) {
     const names = parseToolSelection(source);
@@ -430,8 +443,11 @@ export function applyDeferredToolSurface(session, mode, extraTools = [], options
     // manifest, or the bridge roster + guidance. History stays as is.
     session.mcpServerInstructions = getMcpServerInstructionsMap(session.mcpScopeId);
     applyInitialDeferredToolManifestToBp2(session, deferredPoolToolNames(session), { rebuild: true });
-    const rendered = renderedDeferredManifest(session);
-    session.deferredAnnouncedTools = deferredPoolToolNames(session).filter((name) => rendered.includes(name));
+    session.deferredAnnouncedTools = listedDeferredToolNames(
+      session,
+      deferredPoolToolNames(session),
+      renderedDeferredManifest(session)
+    );
   }
   if (!session.deferredToolBp2Applied && session.messages?.some((m) => m?.role === 'system')) {
     if (!session.mcpServerInstructions || typeof session.mcpServerInstructions !== 'object') {
@@ -519,8 +535,11 @@ export function refreshInitialDeferredMcpSurface(session, liveMcpTools) {
   // Pre-mark ONLY the names that ACTUALLY landed in the rebuilt BP2 manifest as
   // announced; anything the manifest could not advertise stays un-announced so
   // the turn-boundary late reminder can still surface it.
-  const rendered = renderedDeferredManifest(session);
-  session.deferredAnnouncedTools = deferredPoolToolNames(session).filter((name) => rendered.includes(name));
+  session.deferredAnnouncedTools = listedDeferredToolNames(
+    session,
+    deferredPoolToolNames(session),
+    renderedDeferredManifest(session)
+  );
   session.updatedAt = Date.now();
   return true;
 }
@@ -726,7 +745,15 @@ export function selectDeferredTools(session, names, mode, { exact = false } = {}
   const already = [];
   const blocked = [];
   const missing = [];
-  for (const rawName of exact ? [...new Set(names)] : expandSelectionNames(names)) {
+  const requested = exact
+    ? names
+    : expandSelectionNames(names).flatMap((raw) => {
+        const key = clean(raw);
+        if (byName.has(key) || byName.has(key.toLowerCase())) return [key];
+        const members = mcpServerSelection(catalog, key).map((tool) => clean(tool?.name));
+        return members.length ? members : [key];
+      });
+  for (const rawName of new Set(requested)) {
     const requestedName = clean(rawName);
     const tool = byName.get(requestedName) || byName.get(requestedName.toLowerCase());
     const name = clean(tool?.name);

package/src/runtime/agent/orchestrator/runtime-core/tool-defs.mjs

@@ -17,7 +17,8 @@ export const TOOL_SEARCH_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  description: 'Load full schemas for missing deferred tool names/aliases; batch needed names in one call.',
+  description:
+    'Load full schemas for missing deferred tool names/aliases; a connector name loads all its tools; batch needed names in one call.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -72,9 +73,9 @@ export const SESSION_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  trigger: 'Session lookup/control, title, compact, fork, Project and worktrees.',
+  trigger: 'Session lookup/control, agent task sessions, title, compact, fork, Project and worktrees.',
   description:
-    'Inspect sessions or control another by exact ID, never a guessed one. send acknowledges queue intake, not completion. Cancel/delete and worktree actions require the user’s request. Other actions affect only the current session.',
+    'Inspect sessions or control another by exact ID, never a guessed one. send acknowledges queue intake, not completion; promise a report of it only when its result has reportsBack: true. Cancel/delete and worktree actions require the user’s request. Other actions affect only the current session. Pass files on with attachments; a reported turn returns the files it produced as attachments.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -87,6 +88,7 @@ export const SESSION_TOOL = {
           'send',
           'cancel',
           'delete',
+          'create',
           'rename',
           'compact',
           'fork',
@@ -100,9 +102,9 @@ export const SESSION_TOOL = {
           'prune-worktrees',
         ],
         description:
-          'status defaults to current; list pages sessions; read returns latest items; send queues prompt; cancel stops the turn; delete removes the session. compact runs after this turn; fork copies it without switching. merge-worktree merges into the Project’s checked-out branch; remove-worktree returns to the Project (repeat on WORKTREE_REMOVAL_INCOMPLETE); list-worktrees includes retaining sessions; prune-worktrees removes only clean, merged, unretained worktrees.',
+          'status defaults to current; list pages sessions; read returns latest items; send queues prompt (reportsBack: the turn result reports back here); cancel stops the turn; delete removes the session. create (bot conversations) starts a visible agent task session from brief and reports its turns back; unknown Project: list-projects first, still ambiguous: ask the user. compact runs after this turn; fork copies it without switching. merge-worktree merges into the Project’s checked-out branch; remove-worktree returns to the Project (repeat on WORKTREE_REMOVAL_INCOMPLETE); list-worktrees includes retaining sessions; prune-worktrees removes only clean, merged, unretained worktrees.',
       },
-      title: { type: 'string', description: 'rename: new current-session title.' },
+      title: { type: 'string', description: 'rename: new current-session title; create: task title.' },
       session_id: {
         type: 'string',
         description:
@@ -143,6 +145,20 @@ export const SESSION_TOOL = {
         description: 'remove-worktree: allow uncommitted/unmerged work only when explicitly requested.',
       },
       value: { type: 'boolean', description: 'favorite/archive: on or off.' },
+      brief: { type: 'string', description: 'create: self-contained instruction, the first message.' },
+      project: { type: 'string', description: 'create: registered Project name or existing directory.' },
+      model: {
+        type: 'string',
+        description: 'create: provider/model or preset; default is the Lead model (else the last-used one).',
+      },
+      notify: { type: 'boolean', description: 'create: report results back, default true.' },
+      attachments: {
+        type: 'array',
+        items: { type: 'string' },
+        maxItems: 8,
+        description:
+          'send/create: files the target turn receives as real attachments (images, PDF/Office, text): an attachment of this conversation by its file name (a user upload, e.g. its [Image: source: name]) or id (a reported file’s [attachment:id]), or a file path inside this session’s folders. Secret files are refused.',
+      },
     },
     additionalProperties: false,
   },

package/src/runtime/agent/orchestrator/runtime-core/workflow/agents.mjs

@@ -9,6 +9,15 @@ import { readJsonSafe, readTextSafe } from '../fs-utils.mjs';
 import { SHARED_SCAN_REVALIDATE_MS, createSharedScanCache } from './shared-scan-cache.mjs';
 import { isHiddenAgent } from '../../internal-agents.mjs';
 import { isAgentDisabled } from '../../../../shared/agent-route-config.mjs';
+import { agentDefinitionKind } from '../../../../shared/agent-kind.mjs';
+import {
+  BOTS_DIR,
+  MIXY_BOT_ID,
+  botStoreActive,
+  isStoreBot,
+  migratedBotIds,
+  userDefinitionDir,
+} from '../../../../shared/agent-store.mjs';
 import {
   AGENT_DELETED_MARKER,
   AGENT_ROLE_IDS,
@@ -21,16 +30,22 @@ import {
   setAgentDefinitionCache,
 } from '../workflow-ids.mjs';
 
-// Yields its fs requests; see shared-scan-cache.mjs.
-function* scanCustomAgentIds(userRoot, shippedRoot) {
+// Yields its fs requests; see shared-scan-cache.mjs. With the bot store
+// active, bots/ is scanned too and the agents/ originals of the ids the split
+// copied are skipped (agent-store.mjs).
+function* scanCustomAgentIds(userRoot, shippedRoot, botsRoot = null, migrated = new Set()) {
   const ids = new Set();
-  for (const root of [userRoot, shippedRoot]) {
+  for (const root of [...(botsRoot ? [botsRoot] : []), userRoot, shippedRoot]) {
     const entries = yield { op: 'readdir', path: root };
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const id = normalizeWorkflowId(entry.name);
-      if (!id || AGENT_ROLE_IDS.has(id) || isHiddenAgent(id)) continue;
-      if (root !== userRoot && (yield { op: 'exists', path: join(userRoot, id, AGENT_DELETED_MARKER) })) continue;
+      // `lead` is the Lead's own folder, `mixy` Mixy's: neither is an agent.
+      if (!id || id === 'lead' || AGENT_ROLE_IDS.has(id) || isHiddenAgent(id)) continue;
+      if (root === botsRoot && id === MIXY_BOT_ID) continue;
+      if (root === userRoot && migrated.has(id)) continue;
+      if (root === botsRoot && entry.name !== id) continue;
+      if (root === shippedRoot && (yield { op: 'exists', path: join(userRoot, id, AGENT_DELETED_MARKER) })) continue;
       if (!(yield { op: 'exists', path: join(root, entry.name, 'AGENT.md') })) continue;
       ids.add(id);
     }
@@ -56,15 +71,24 @@ const agentListCache = createSharedScanCache();
 
 export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, normalizeAgentPermissionOrNone }) {
   function agentSourceDirs(dir, id) {
+    // A store bot reads only its own folder (agent-store.mjs).
+    if (isStoreBot(dir || dataDir, id)) return [userDefinitionDir(dir || dataDir, id)];
     const userDir = join(dir || dataDir, 'agents', id);
     if (existsSync(join(userDir, AGENT_DELETED_MARKER))) return [userDir];
     return [userDir, join(rootDir, 'agents', id)];
   }
 
   function agentScan(dir) {
-    const userRoot = join(dir || dataDir, 'agents');
+    const base = dir || dataDir;
+    const userRoot = join(base, 'agents');
     const shippedRoot = join(rootDir, 'agents');
-    return { key: `${userRoot}\n${shippedRoot}`, makeScan: () => scanCustomAgentIds(userRoot, shippedRoot) };
+    const store = botStoreActive(base);
+    const migrated = store ? migratedBotIds(base) : new Set();
+    const botsRoot = store ? join(base, BOTS_DIR) : null;
+    return {
+      key: `${userRoot}\n${shippedRoot}\n${botsRoot || ''}\n${[...migrated].join(',')}`,
+      makeScan: () => scanCustomAgentIds(userRoot, shippedRoot, botsRoot, migrated),
+    };
   }
 
   function listCustomAgentIds(dir) {
@@ -100,7 +124,16 @@ export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, n
         description: clean(manifest.description) || slot?.description || '',
         permission: normalizeAgentPermissionOrNone(doc.frontmatter.permission),
         frontmatter: doc.frontmatter,
+        // bot | agent | null, decided read-only (shared/agent-kind.mjs).
+        kind: agentDefinitionKind({
+          frontmatterKind: doc.frontmatter.kind,
+          ...(d !== join(rootDir, 'agents', agentId)
+            ? { dataDir: dir || dataDir, shippedRoot: rootDir, id: agentId, manifest, body }
+            : {}),
+        }),
         body,
+        // Optional PERSONA.md beside AGENT.md (same dir, same cache entry).
+        persona: (readTextSafe(join(d, 'PERSONA.md')) || '').trim(),
       };
       setAgentDefinitionCache(cacheKey, definition);
       return definition;