ModelChildrenOptions

SUPPORT · interface · Type contract

Group options: worker count, extra cancellation and accept/commit hooks.

Import

TypeScript

import type { ModelChildrenOptions } from '@jangts/agent-core/support';

JavaScript

/** @typedef {import('@jangts/agent-core/support').ModelChildrenOptions} ModelChildrenOptions */

Other public entry points:@jangts/agent-core/support, @jangts/agent-core/support/model.

Definition

interface ModelChildrenOptions<Value>

Type parameters

Type parameter	Constraint	Default type
Value	—	—

Field structure

Field	Type	Required	Description
concurrency	number | undefined	Optional	Read-only. Parallel workers; defaults to, and may not exceed, the parent's concurrency limit.
signal	AbortSignal | undefined	Optional	Read-only. Optional caller cancellation, combined with the parent signal and group failure.
accept	((value: Value, id: string) => MaybePromise<void>) | undefined	Optional	Called as each task finishes, before commit; must settle with void.
commit	((value: Value, id: string) => MaybePromise<void>) | undefined	Optional	Called in declaration order after every result is accepted; App owns atomicity/receipts.

Examples

• Child task composition: sequential execution and controlled parallelism: Reuse createChild and the shared budget, check every result, and commit in declaration order.

Analyze two documents in sequence

Beginner · Node.js

TypeScript

import { ModelRunner, Support } from '@jangts/agent-core';
import type { ChatProvider } from '@jangts/agent-core';

export async function analyze(provider: ChatProvider, inputs: readonly [string, string], signal: AbortSignal) {
  const model = new ModelRunner({ provider, maxCalls: 5, execution: { signal } });
  return Support.runChildren(model, inputs.map((input, index) => ({
    id: 'analysis-' + index, maxCalls: 2, reserveCalls: 1, timeoutMs: 30000, transports: [],
    async run(child: ModelRunner) { return (await child.invoke(input)).value; },
  })), {
    accept(value) { if (!value.trim()) throw new Error('分析结果为空'); },
  });
}

JavaScript

import { ModelRunner, Support } from '@jangts/agent-core';
export async function analyze(provider, inputs, signal) {
    const model = new ModelRunner({ provider, maxCalls: 5, execution: { signal } });
    return Support.runChildren(model, inputs.map((input, index) => ({
        id: 'analysis-' + index, maxCalls: 2, reserveCalls: 1, timeoutMs: 30000, transports: [],
        async run(child) { return (await child.invoke(input)).value; },
    })), {
        accept(value) { if (!value.trim())
            throw new Error('分析结果为空'); },
    });
}

Add concurrent capacity to the same set of analyses

Configuration · Node.js

The same function and task list, adding only the root Runner capacity setting. Local budgets and the parent reservation still apply.

TypeScript

import { ModelRunner, Support } from '@jangts/agent-core';
import type { ChatProvider } from '@jangts/agent-core';

export async function analyze(provider: ChatProvider, inputs: readonly [string, string], signal: AbortSignal) {
  const model = new ModelRunner({ provider, maxCalls: 5, execution: { signal }, children: { maxConcurrentCalls: 2 } });
  return Support.runChildren(model, inputs.map((input, index) => ({
    id: 'analysis-' + index, maxCalls: 2, reserveCalls: 1, timeoutMs: 30000, transports: [],
    async run(child: ModelRunner) { return (await child.invoke(input)).value; },
  })), {
    accept(value) { if (!value.trim()) throw new Error('分析结果为空'); },
  });
}

JavaScript

import { ModelRunner, Support } from '@jangts/agent-core';
export async function analyze(provider, inputs, signal) {
    const model = new ModelRunner({ provider, maxCalls: 5, execution: { signal }, children: { maxConcurrentCalls: 2 } });
    return Support.runChildren(model, inputs.map((input, index) => ({
        id: 'analysis-' + index, maxCalls: 2, reserveCalls: 1, timeoutMs: 30000, transports: [],
        async run(child) { return (await child.invoke(input)).value; },
    })), {
        accept(value) { if (!value.trim())
            throw new Error('分析结果为空'); },
    });
}

Related policy source

• Child acceptance, cancellation, and ordered commit

Related definitions

• MaybePromise