@byokit/openclaw 0.24.0 → 0.25.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+## 0.25.0 (2026-10-20)
+
+- Dependency update: pins @byokit/accounts 0.29.0.
+
+- FEAT: a MiniMax API key now lists and runs any model MiniMax's own `/models` lists, with no BYOKit model list: `kit.models({ authChoice: 'minimax-global-api' })` answers the vendor's models, and `addKey({ ..., model })` takes an id the list lags (such as `MiniMax-M3.1-Flash-Preview`) with the route's own capabilities (image input included) instead of refusing it or falling back to `MiniMax-M3`.
+- FIX: When a child a run sent work to (`sessions_send`, `timeoutSeconds: 0`) finished, the engine's own reply run bringing its report back to the sender's session was refused `unknown run` at every app tool. That return run is now admitted as the sender: same member and helper, same app-tool subset and delegates, and the sender's system text as its persona; `RunRef.parent` names the finished child. Any other run on that session is still refused.
+
 ## 0.24.0 (2026-10-20)
 
 - FEAT: a helper's delegated run now speaks as its helper. A native `sessions_send` carries no system text, so the kit's plugin adds the helper's recorded persona (from `ensureHelper`) as system context to the admitted helper child's run, and only to it. No app change: Chief's `helperDelegates` send to `agent:<agent>:h-<helper>:<rest>` is enough. The kit plugin's config entry now sets `hooks.allowConversationAccess: true` for this hook. `sessions_spawn` children get no persona.

package/README.md

@@ -452,6 +452,13 @@ and terminal observations with exact `runId`, `agentId`, `member`, `sessionKey`,
 The same identity reaches `ToolHost`; each delegated action has its own gate/approval. Tool arguments/results
 are omitted from this event surface. An accepted native dispatch is not finished work or proof of delivery.
 
+When a sent child finishes, the engine starts its own reply run on the sender's session to bring the report back.
+The kit admits that exact run as the sender: same member and helper, same app-tool subset and delegates, the sender's
+`system` as its persona, `RunRef.parent` naming the finished child. Only a run whose prompt the engine headed with that
+child's session, on the sender's exact key, within a minute of the child's (or the previous return turn's) end, binds;
+any other run there stays unknown. Return runs are not on `delegatedRuns()` or `byokit.delegated`; read them from the
+engine's `agent` events on the sender's key. The pinned engine starts no reply run for a child that took over 30 s.
+
 Admitted exact run IDs survive parent settlement and are reconciled on reconnect/start; a child the engine no longer
 knows (as after an engine restart) ends `lost`, and a dispatch that finds the journal full reconciles first. `abort(rootSessionKey)`
 durably revokes its recorded subtree, closes parked gates/active calls, then asks the engine to abort; a child key

package/dist/bridge.js

@@ -332,11 +332,13 @@ export class Bridge {
                     delegations.event(message.event);
                     this.reply(socket, { ok: true });
                 }
-                // The plugin's prompt hook on a helper key: an admitted helper child speaks as its helper (5.8.3).
+                // The plugin's prompt hook on a helper key or an inter-session prompt: an admitted helper child speaks as its
+                // helper (5.8.3), a return run as the kit run that sent the work (5.8.4).
                 else if (message.kind === 'delegation-persona' && typeof message.key === 'string') {
                     const runId = typeof message.runId === 'string' ? message.runId : undefined;
                     // A kit run carries its own persona; only an engine-created child is looked up (it may wait for its receipt).
-                    const persona = runId && this.isRegisteredRun(message.key, runId) ? undefined : await delegations.persona(message.key, runId);
+                    const persona = runId && this.isRegisteredRun(message.key, runId) ? undefined
+                        : await delegations.persona(message.key, runId, typeof message.header === 'string' ? message.header : undefined);
                     this.reply(socket, persona === undefined ? {} : { persona });
                 }
                 else

package/dist/constants.d.ts

@@ -2,4 +2,5 @@ export declare const ENGINE_VERSION = "2026.8.35";
 export declare const PROTOCOL_VERSION = 4;
 export declare const LIVE_CATALOGS: string[];
 export declare const REGISTERED_CATALOGS: string[];
+export declare const OPEN_CATALOGS: string[];
 export declare const OPERATOR_SCOPES: readonly ['operator.read', 'operator.write', 'operator.admin', 'operator.approvals', 'operator.questions', 'operator.pairing', 'operator.talk'];

package/dist/constants.js

@@ -4,10 +4,13 @@ export const ENGINE_VERSION = '2026.8.35';
 export const PROTOCOL_VERSION = 4;
 // Providers whose live catalog lists and checks a key's chosen model (5.6), through the catalog hook. OpenRouter is
 // pay-as-you-go: its key takes any model its own catalog lists, with no plan to include it.
-export const LIVE_CATALOGS = ['opencode-go', 'openrouter'];
+export const LIVE_CATALOGS = ['opencode-go', 'openrouter', 'minimax'];
 // Live catalogs the kit registers whole. The engine canonicalizes Google preview ids on config write, so OpenRouter's
 // list collides with itself (`google/x-preview` and `google/x`); an OpenRouter add registers only the chosen model.
-export const REGISTERED_CATALOGS = ['opencode-go'];
+export const REGISTERED_CATALOGS = ['opencode-go', 'minimax'];
+// Pay-as-you-go catalogs whose vendor list can lag a model that already runs: an id the list lacks is warned about, never
+// refused, and takes the capabilities of the route's own models.
+export const OPEN_CATALOGS = ['minimax'];
 export const OPERATOR_SCOPES = [
     'operator.read',
     'operator.write',

package/dist/delegations.d.ts

@@ -1,16 +1,26 @@
 import type { DelegatedEvent, DelegatedRun, GatewayTransport, RunRef } from './types.ts';
+type Back = {
+    member: string;
+    helper?: string;
+    tools: string[];
+    helpers?: Record<string, string[]>;
+};
 type Grant = {
     ref: DelegatedRun;
     tools: string[];
     delegates: Record<string, string[]>;
     helpers?: Record<string, string[]>;
     sourceKey: string;
+    back?: Back;
 };
 export declare class Delegations {
     private loaded;
     private roots;
     private children;
     private pending;
+    private personas;
+    private armed;
+    private returns;
     private changed;
     private early;
     constructor(privateOptions: {
@@ -31,15 +41,19 @@ export declare class Delegations {
     private load;
     private save;
     validate(delegates: Record<string, string[]>, member?: string, helpers?: Record<string, string[]>): void;
-    register(ref: RunRef, runId: string, tools: readonly string[] | undefined, delegates: Record<string, string[]>, sourceKey?: string, helpers?: Record<string, string[]>): () => void;
+    register(ref: RunRef, runId: string, tools: readonly string[] | undefined, delegates: Record<string, string[]>, sourceKey?: string, helpers?: Record<string, string[]>, system?: string): () => void;
     list(): DelegatedRun[];
     has(key: string, runId: string): boolean;
     private full;
     prepare(m: Record<string, any>): Promise<boolean>;
     receipt(m: Record<string, any>): void;
     resolve(key: string, runId?: string): Promise<Grant | undefined>;
-    /** The persona of the admitted helper child on this exact key and run, as its own run would carry it (5.8.3). */
-    persona(key: string, runId?: string): Promise<string | undefined>;
+    /** The persona of the admitted helper child on this exact key and run, as its own run would carry it (5.8.3), or of
+     * the return run on its sender's key (5.8.4): `header` is the engine's inter-session header on that run's prompt. */
+    persona(key: string, runId?: string, header?: string): Promise<string | undefined>;
+    private bind;
+    private returned;
+    private arm;
     private bound;
     event(event: Record<string, any>): void;
     private ended;

package/dist/delegations.js

@@ -5,6 +5,11 @@ import { classify } from './classify.js';
 import { HELPER_ID, HelperError, helperOf } from './helpers.js';
 // A resting end whose message names no time rests the account this long, as a kit run's does (runs.ts).
 const REST_MS = 300_000;
+// A return binds within this long of its child's end (or of its previous turn's end): the engine's own reply step waits
+// at most 60 s for the child before it starts.
+const RETURN_MS = 60_000;
+// The engine's own header on an inter-session prompt (pin `annotateInterSessionPromptText`), naming the source session.
+const INTER_SESSION = /^\[Inter-session message\] sourceSession=(\S+)(?: sourceChannel=\S+)? sourceTool=sessions_send isUser=false$/;
 const object = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 const agentOf = (key) => /^agent:([^:]+):.+/.exec(key)?.[1];
 const actionKey = (m) => JSON.stringify([m.key, m.runId, m.callId]);
@@ -13,6 +18,10 @@ export class Delegations {
     roots = new Map();
     children = new Map();
     pending = new Map();
+    // In memory only (no prompt is persisted): a kit run's system text by its run id, its return runs' persona.
+    personas = new Map();
+    armed = [];
+    returns = new Map();
     changed = new Set();
     early = new Map();
     constructor(privateOptions) { this.o = privateOptions; }
@@ -56,9 +65,13 @@ export class Delegations {
             this.o.helper(member, helper); // never ensured, or its account gone: unknown_helper
         }
     }
-    register(ref, runId, tools, delegates, sourceKey = ref.sessionKey, helpers) {
+    register(ref, runId, tools, delegates, sourceKey = ref.sessionKey, helpers, system = '') {
         this.load();
         this.validate(delegates, ref.member, helpers);
+        // ponytail: the oldest 256 kit runs' system texts are kept; a child of an older one gets no return run (fail closed).
+        this.personas.set(runId, system);
+        while (this.personas.size > 256)
+            this.personas.delete(this.personas.keys().next().value);
         const root = { ref: { ...ref, runId, root: { sessionKey: ref.sessionKey, runId } },
             tools: [...tools ?? this.o.tools], delegates: structuredClone(delegates), ...(helpers ? { helpers: structuredClone(helpers) } : {}), sourceKey };
         this.roots.set(runId, root);
@@ -68,7 +81,7 @@ export class Delegations {
     list() { this.load(); return [...this.children.values()].map(g => structuredClone(g.ref)); }
     has(key, runId) {
         this.load();
-        return (this.roots.get(runId) ?? this.children.get(runId))?.ref.sessionKey === key;
+        return (this.roots.get(runId) ?? this.children.get(runId) ?? this.returns.get(runId))?.ref.sessionKey === key;
     }
     full() {
         for (const [id, p] of this.pending)
@@ -83,7 +96,7 @@ export class Delegations {
         // ponytail: a full journal of live children re-reads all 1024 per dispatch; index ends by age if that shows up.
         if (this.full())
             await this.reconcile();
-        const parent = this.roots.get(m.runId) ?? this.children.get(m.runId);
+        const parent = this.roots.get(m.runId) ?? this.children.get(m.runId) ?? this.returns.get(m.runId);
         if (!parent || parent.ref.sessionKey !== m.key)
             return false;
         if (typeof m.callId !== 'string' || !m.callId || !object(m.input))
@@ -111,8 +124,11 @@ export class Delegations {
         }
         if (this.full())
             throw new Error('delegated run journal is full');
-        this.pending.set(actionKey(m), { parent: structuredClone(parent), agent: agent,
-            ...(send ? { key: m.input.sessionKey } : {}), ...(helper !== undefined ? { helper } : {}), expires: Date.now() + 60_000 });
+        const { persona: _, ...grant } = parent; // a return's persona is never persisted
+        this.pending.set(actionKey(m), { parent: structuredClone(grant), agent: agent,
+            ...(send ? { key: m.input.sessionKey } : {}), ...(helper !== undefined ? { helper } : {}),
+            // The engine brings a sent child's report back to the sender's key, as a return run (5.8.4); a spawn's is not one.
+            ...(send && !this.children.has(m.runId) ? { back: true } : {}), expires: Date.now() + 60_000 });
         this.save();
         return true;
     }
@@ -143,7 +159,9 @@ export class Delegations {
             parent: { sessionKey: p.parent.ref.sessionKey, runId: p.parent.ref.runId }, root: p.parent.ref.root, tools };
         const grant = { ref, delegates: p.parent.delegates,
             ...(p.parent.helpers && ref.member === p.parent.ref.member ? { helpers: p.parent.helpers } : {}),
-            sourceKey: p.parent.sourceKey, tools };
+            sourceKey: p.parent.sourceKey, tools,
+            ...(p.back ? { back: { member: p.parent.ref.member, ...(p.parent.ref.helper !== undefined ? { helper: p.parent.ref.helper } : {}),
+                    tools: p.parent.tools, ...(p.parent.helpers ? { helpers: p.parent.helpers } : {}) } } : {}) };
         // A steered/already-admitted run keeps its original parent and cannot acquire a broader grant.
         if (this.children.has(ref.runId)) {
             this.save();
@@ -160,6 +178,13 @@ export class Delegations {
         this.load();
         if (!runId)
             return undefined;
+        const back = this.returns.get(runId);
+        if (back?.ref.sessionKey === key) {
+            if (back.ref.helper === undefined || this.bound(back.ref.member, back.ref.helper, back.ref.agentId))
+                return back;
+            this.returned(runId);
+            return undefined;
+        }
         const get = () => { const g = this.children.get(runId); return g?.ref.sessionKey === key ? g : undefined; };
         if (!get() && [...this.pending.values()].some(p => p.expires > Date.now())) {
             await new Promise(resolve => {
@@ -179,11 +204,68 @@ export class Delegations {
         }
         return grant;
     }
-    /** The persona of the admitted helper child on this exact key and run, as its own run would carry it (5.8.3). */
-    async persona(key, runId) {
+    /** The persona of the admitted helper child on this exact key and run, as its own run would carry it (5.8.3), or of
+     * the return run on its sender's key (5.8.4): `header` is the engine's inter-session header on that run's prompt. */
+    async persona(key, runId, header) {
+        this.load();
+        const source = header === undefined ? undefined : INTER_SESSION.exec(header)?.[1];
+        if (runId && source !== undefined && !this.returns.has(runId) && !this.children.has(runId))
+            await this.bind(key, runId, source);
+        const back = runId ? this.returns.get(runId) : undefined;
+        if (back?.ref.sessionKey === key)
+            return back.persona || undefined;
+        if (!/^agent:[^:]+:h-/.test(key))
+            return undefined;
         const helper = (await this.resolve(key, runId))?.ref;
         return helper?.helper === undefined ? undefined : this.o.helper(helper.member, helper.helper).persona;
     }
+    // The engine's reply step for a sent child starts a fresh run on the sender's exact key, its prompt headed by the
+    // child's exact session (pin `runSessionsSendA2AFlow`): bound only to a return armed by that child's own terminal end,
+    // one run at a time. A child still running when its report arrives is waited for briefly.
+    async bind(key, runId, source) {
+        const find = () => {
+            const now = Date.now();
+            this.armed = this.armed.filter(a => a.expires > now);
+            return this.armed.find(a => a.key === key && a.child.sessionKey === source && a.live === undefined);
+        };
+        if (!find() && [...this.children.values()].some(g => g.back && g.ref.sessionKey === source && g.ref.parent.sessionKey === key)) {
+            await new Promise(resolve => {
+                const done = () => { clearTimeout(timer); this.changed.delete(check); resolve(); };
+                const check = () => { if (find())
+                    done(); };
+                const timer = setTimeout(done, 5_000);
+                this.changed.add(check);
+            });
+        }
+        const armed = find();
+        if (!armed)
+            return;
+        armed.live = runId;
+        this.returns.set(runId, { ...structuredClone(armed.grant), ref: { ...structuredClone(armed.grant.ref), runId }, persona: armed.persona });
+    }
+    // A return run ended: its report's next turn on the same key may bind within the window (the engine's ping-pong).
+    returned(runId) {
+        const back = this.returns.get(runId);
+        if (!back)
+            return;
+        this.returns.delete(runId);
+        this.o.revoke(back.ref.sessionKey, runId);
+        const armed = this.armed.find(a => a.live === runId);
+        if (armed) {
+            armed.live = undefined;
+            armed.expires = Date.now() + RETURN_MS;
+        }
+    }
+    arm(child) {
+        const { back, ref } = child, persona = this.personas.get(ref.root.runId);
+        if (!back || persona === undefined || this.armed.length >= 64)
+            return; // the root's persona unknown (a restart): none
+        const key = ref.parent.sessionKey;
+        this.armed.push({ key, child: { sessionKey: ref.sessionKey, runId: ref.runId }, persona, expires: Date.now() + RETURN_MS,
+            grant: { ref: { sessionKey: key, member: back.member, ...(back.helper !== undefined ? { helper: back.helper } : {}),
+                    agentId: agentOf(key), parent: { sessionKey: ref.sessionKey, runId: ref.runId }, root: ref.root, tools: back.tools },
+                tools: back.tools, delegates: child.delegates, ...(back.helpers ? { helpers: back.helpers } : {}), sourceKey: child.sourceKey } });
+    }
     bound(member, helper, agent) {
         try {
             return this.o.helper(member, helper).agentId === agent;
@@ -194,6 +276,12 @@ export class Delegations {
     }
     event(event) {
         this.load();
+        const back = this.returns.get(event.runId);
+        if (back) {
+            if (event.sessionKey === back.ref.sessionKey && event.stream === 'lifecycle' && ['end', 'error'].includes(event.data?.phase))
+                this.returned(event.runId);
+            return;
+        }
         const grant = this.children.get(event.runId);
         if (!grant) {
             if (this.pending.size && typeof event.runId === 'string' && this.early.size < 64) {
@@ -232,6 +320,8 @@ export class Delegations {
     }
     end(grant, end) {
         this.children.delete(grant.ref.runId);
+        if (end.reason === 'terminal')
+            this.arm(grant); // before save: a return run waiting on this end sees it armed
         this.save();
         this.o.revoke(grant.ref.sessionKey, grant.ref.runId);
         this.o.emit({ type: 'ended', run: structuredClone(grant.ref), ...end });
@@ -260,7 +350,7 @@ export class Delegations {
     async abort(key) {
         this.load();
         const ids = new Set();
-        for (const g of [...this.roots.values(), ...this.children.values()])
+        for (const g of [...this.roots.values(), ...this.children.values(), ...this.returns.values()])
             if (g.ref.sessionKey === key || g.ref.parent?.sessionKey === key || g.ref.root.sessionKey === key || g.sourceKey === key)
                 ids.add(g.ref.runId);
         for (;;) {
@@ -272,6 +362,10 @@ export class Delegations {
                 break;
         }
         let removed = false;
+        const armed = this.armed.length;
+        this.armed = this.armed.filter(a => a.key !== key && a.grant.ref.root.sessionKey !== key && !ids.has(a.child.runId) && !ids.has(a.grant.ref.root.runId));
+        if (this.armed.length !== armed)
+            removed = true;
         for (const [id, p] of this.pending)
             if (ids.has(p.parent.ref.runId) || p.parent.ref.sessionKey === key || p.parent.ref.root.sessionKey === key || p.parent.sourceKey === key) {
                 this.pending.delete(id);
@@ -280,9 +374,11 @@ export class Delegations {
         if (!ids.size && !removed)
             return;
         const cancelled = [...this.children.values()].filter(g => ids.has(g.ref.runId));
-        const revoked = [...this.roots.values(), ...cancelled].filter(g => ids.has(g.ref.runId));
-        for (const id of ids)
+        const revoked = [...this.roots.values(), ...this.returns.values(), ...cancelled].filter(g => ids.has(g.ref.runId));
+        for (const id of ids) {
             this.roots.delete(id);
+            this.returns.delete(id);
+        }
         for (const g of cancelled)
             this.children.delete(g.ref.runId);
         this.save(); // revoke durably before any awaited transport call

package/dist/keys.js

@@ -5,7 +5,7 @@ import { activate } from './activation.js';
 import { keyAgentId, MEMBER_ID, KEY_PREFIX, untilListed } from './members.js';
 import { providerOf } from './pick.js';
 import { kitId, modelsOf } from './accounts.js';
-import { LIVE_CATALOGS, REGISTERED_CATALOGS } from './constants.js';
+import { LIVE_CATALOGS, OPEN_CATALOGS, REGISTERED_CATALOGS } from './constants.js';
 export function createKeys(ctx) {
     // Serialize key replacement and key runs, so an in-flight run never sees a half-installed replacement.
     const tails = new Map();
@@ -93,6 +93,16 @@ export function createKeys(ctx) {
         throw new Error(keyed.length ? `${authChoice} takes no API key: add the key with ${keyed.map((r) => r.choice).join(' or ')}.`
             : `${authChoice} takes no API key.`);
     };
+    // The vendor's list can lag a model that runs: an id it lacks rides the route's own models (the richest row's api,
+    // base URL and context, every input modality any row takes), unpriced. Nothing is added to an empty list.
+    const unlisted = (provider, rows, model) => {
+        if (!rows.length || rows.some((m) => kitId(provider, String(m.id)) === model))
+            return [];
+        const base = rows.reduce((a, b) => (Number(b.contextWindow) || 0) > (Number(a.contextWindow) || 0) ? b : a);
+        const input = ['text', 'image'].filter((i) => rows.some((m) => Array.isArray(m.input) && m.input.includes(i)));
+        const id = model.slice(provider.length + 1);
+        return [{ ...base, id, name: id, input, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } }];
+    };
     const listed = (provider, rows) => modelsOf(provider, { models: rows.map((m) => ({ ...m, provider })) });
     const models = async (member, o) => {
         if (!check(member))
@@ -217,6 +227,8 @@ export function createKeys(ctx) {
                         if (result.late)
                             return abandon(failure('retry', 'busy'));
                         const rows = model === undefined ? [] : await catalog(member, route.provider);
+                        const lagging = model !== undefined && OPEN_CATALOGS.includes(route.provider) ? unlisted(route.provider, rows, model) : [];
+                        rows.push(...lagging);
                         if (model !== undefined && !listed(route.provider, rows).some((m) => m.id === model && m.available))
                             return abandon(failure('not_included', 'model'));
                         // Prepare before publishing the ready marker: failed preparation remains unusable even if clear fails.
@@ -229,7 +241,7 @@ export function createKeys(ctx) {
                         if (ac.signal.aborted)
                             return abandon(cancelled());
                         // A live catalog the kit does not register whole (OpenRouter) registers the chosen model alone.
-                        if (model !== undefined && !REGISTERED_CATALOGS.includes(route.provider))
+                        if (model !== undefined && (!REGISTERED_CATALOGS.includes(route.provider) || lagging.length))
                             await ctx.registerModels(route.provider, rows.filter((m) => kitId(route.provider, String(m.id)) === model)).catch(() => { });
                         if (model !== undefined && LIVE_CATALOGS.includes(route.provider) && !(await registered(route.provider, model)))
                             return abandon(failure('retry', 'model'));

package/dist/runs.js

@@ -347,7 +347,7 @@ export function createRuns(ctx) {
         try {
             const ref = { sessionKey, member: spec.member, ...(spec.helper !== undefined ? { helper: spec.helper } : {}) };
             releaseDelegation = spec.delegates || spec.helperDelegates
-                ? ctx.delegations.register(ref, idempotencyKey, spec.tools, spec.delegates ?? {}, spec.sessionKey, spec.helperDelegates) : undefined;
+                ? ctx.delegations.register(ref, idempotencyKey, spec.tools, spec.delegates ?? {}, spec.sessionKey, spec.helperDelegates, system) : undefined;
             release = spec.register !== false ? ctx.bridge.register(ref, spec.tools, idempotencyKey) : undefined;
             if (picked && !chosen) {
                 // The picked account must be the one called: check it is signed in for this member before the run, since

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "The OpenClaw runtime kit: the pinned engine's full operator surface with plain-words helpers for members, sign-in, runs and approvals.",
   "license": "Apache-2.0",
   "type": "module",
@@ -60,7 +60,7 @@
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"
   },
   "dependencies": {
-    "@byokit/accounts": "0.28.2",
+    "@byokit/accounts": "0.29.0",
     "@byokit/pair": "0.10.4",
     "@byokit/relay": "0.8.2",
     "@byokit/discover": "0.8.4",

package/plugin/catalog.js

@@ -38,6 +38,19 @@ export function registerCatalog(api) {
         const models = [...live.models, ...(pinned?.models ?? []).filter((m) => !liveIds.has(m.id))]
           .map(({ provider: _p, apiKey: _k, headers: _h, ...model }) =>
             (endpoint.has(model.api) ? { ...model, baseUrl: endpoint.get(model.api) } : model));
+        // MiniMax's engine catalog is a fixed list: its vendor `/models` lists newer ids, which join it with the richest
+        // row's api, base URL and capabilities (the vendor lists ids only). A failed fetch keeps the engine's list.
+        if (provider === 'minimax' && models.length) {
+          const base = models.reduce((a, b) => (b.contextWindow ?? 0) > (a.contextWindow ?? 0) ? b : a);
+          const input = ['text', 'image'].filter((i) => models.some((m) => m.input?.includes(i)));
+          const listed = await fetch(`${String(base.baseUrl).replace(/\/$/, '')}/v1/models`,
+            { headers: { authorization: `Bearer ${apiKey}`, 'anthropic-version': '2023-06-01' }, signal: AbortSignal.timeout(10_000) })
+            .then((r) => r.ok ? r.json() : null, () => null);
+          const have = new Set(models.map((m) => m.id));
+          for (const m of Array.isArray(listed?.data) ? listed.data : [])
+            if (typeof m?.id === 'string' && m.id && !have.has(m.id))
+              models.push({ ...base, id: m.id, name: m.display_name || m.id, input, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } });
+        }
         return respond(true, { ok: true, models });
       }
       respond(true, { ok: false, reason: unreadable ? 'failed' : 'no-key' });

package/plugin/index.js

@@ -160,12 +160,16 @@ export default {
         result: { details: d && { status: d.status, runId: d.runId, sessionKey: d.sessionKey, childSessionKey: d.childSessionKey } } });
     });
     // A native send carries no system text: an admitted helper child gets its helper's persona from the kit (5.8.3).
-    // Any other run, or no answer, adds nothing; the persona is the helper's voice, never a grant.
-    api.on('before_prompt_build', async (_event, ctx) => {
+    // The engine's reply step bringing a sent child's report back (an inter-session prompt) asks too: the kit binds that
+    // exact run as the sender's return run (5.8.4) and answers the sender's persona. Any other run, or no answer, adds
+    // nothing; the persona is a voice, never a grant.
+    api.on('before_prompt_build', async (event, ctx) => {
       const key = ctx?.sessionKey;
-      if (typeof key !== 'string' || !/^agent:[^:]+:h-[a-z][a-z0-9-]{0,15}:/.test(key)) return undefined;
+      const header = typeof event?.prompt === 'string' && event.prompt.startsWith('[Inter-session message] ')
+        ? event.prompt.slice(0, 1024).split('\n', 1)[0] : undefined;
+      if (typeof key !== 'string' || (!header && !/^agent:[^:]+:h-[a-z][a-z0-9-]{0,15}:/.test(key))) return undefined;
       try {
-        const reply = await bridgeRequest({ kind: 'delegation-persona', key, runId: ctx?.runId }, { timeoutMs: 10_000 });
+        const reply = await bridgeRequest({ kind: 'delegation-persona', key, runId: ctx?.runId, ...(header ? { header } : {}) }, { timeoutMs: 10_000 });
         if (typeof reply?.persona === 'string' && reply.persona) return { appendSystemContext: reply.persona };
       } catch { /* no kit: nothing added */ }
       return undefined;