@jangts/agent-core 0.3.5 → 0.3.6

package/dist/esm/structs/execution/workflow.d.ts

@@ -1,3 +1,4 @@
+import type { WorkflowChainSource } from './workflow-views.js';
 /**
  * Workflow contract: a state graph whose nodes report their own use of model and tools.
  *
@@ -66,8 +67,6 @@ export interface WorkflowNodeReport {
     readonly usedModel?: boolean;
     /** App-defined progress detail; collected only when content logging is enabled. */
     readonly payload?: unknown;
-    /** Logger owned by this visit, used to report sub-steps. */
-    readonly subs?: import('../debug.js').SubFlowLogger;
 }
 /** One node of the graph. */
 export type WorkflowNode<State, Result, Runtime = undefined> = {
@@ -94,7 +93,7 @@ export type WorkflowNode<State, Result, Runtime = undefined> = {
     readonly requires?: readonly (keyof State & string)[];
     /** State keys this node is expected to produce; validated after `run`. */
     readonly provides?: readonly (keyof State & string)[];
-    /** Candidate successors, evaluated in order. */
+    /** Candidate successors, evaluated in order. A getter must be pure; registration reads it once. */
     readonly routes: readonly WorkflowRoute<State, Result, Runtime>[];
     /** Return only changed fields. Core commits them after cancellation and output checks. */
     readonly run?: (state: Readonly<State>, context: WorkflowContext<Runtime>) => void | Partial<State> | Promise<void | Partial<State>>;
@@ -103,6 +102,8 @@ export type WorkflowNode<State, Result, Runtime = undefined> = {
 export type AgentWorkflowDefinition<State, Result, Runtime = undefined> = {
     /** Stable workflow id, also reported in every event. */
     readonly id: string;
+    /** App-owned authorized diagnostic reader; no global run storage is installed. */
+    readonly chainSource?: WorkflowChainSource;
     /** Definition revision; lets hosts distinguish executions of different graph versions. */
     readonly revision?: string;
     readonly nodes: readonly WorkflowNode<State, Result, Runtime>[];

package/dist/esm/structs/index.d.ts

@@ -55,3 +55,4 @@ export type * from './invocation.js';
 export type * from './debug.js';
 export type * from './execution/events.js';
 export type * from './execution/cache.js';
+export type * from './execution/workflow-views.js';

package/dist/esm/structs/model/runtime.d.ts

@@ -175,6 +175,8 @@ export type ModelRunnerOptions<Transports extends readonly ModelTransportDefinit
 } & ModelRunnerSettings;
 /** One model call request. The input shape selects prompt mode or message mode. */
 export type ModelCallRequest<Transport = string> = {
+    /** Record this call in the supplied logger; omission adds no sub-flow record. */
+    readonly logger?: import('../debug.js').SubFlowLogger;
     /** Additional cancellation can shorten, never replace, the Runner lifetime. */
     readonly signal?: AbortSignal;
     /** Parent observation scope for this invocation; never changes execution budget or signal. */

package/dist/esm/support/context/nodes.js

@@ -9,6 +9,7 @@
  * Main exports: `createContextProcessingNode`, `createContextSelectionNode`,
  * `createContextReductionNode` and their result/definition types.
  */
+import { nativeSubFlowAsync } from '../../diagnostics/native-sub-flow.js';
 import { beginContextProcessing, finishContextProcessing, chooseSteps, applyReduction, needsReduction, watermarks, validateReductionTargets, contextPolicyCatalog, validateContextPolicy, } from './processing.js';
 import { modelRunnerDefaults } from '../../model/defaults.js';
 import { synchronous } from '../../utils/synchronous.js';
@@ -124,53 +125,55 @@ function contextNode(definition, execute) {
         onErrorRouteId: definition.onErrorRouteId,
         routes: definition.routes,
         async run(state, context) {
-            // The node timeout is an additional bound; parent cancellation still wins.
-            const signal = combineSignals(context.signal, AbortSignal.timeout(timeoutMs));
-            const prepared = selectPrepared
-                ? selectPrepared(state, context)
-                : context.model.prepare(typeof request === 'function' ? request(state, context) : request);
-            const input = synchronous(plan(state, context), 'Context plans must be synchronous');
-            // An empty measurement reports the allowance left after transport, instruction and schema
-            // overhead, so processing must fit inside whichever limit is tighter.
-            const overhead = prepared.measure([]);
-            const fullLimit = Math.min(input.maxInputChars, overhead.maxInputChars);
-            const bodyLimit = fullLimit;
-            breakWhile(bodyLimit < 1, 'No input capacity for context');
-            const work = beginContextProcessing({
-                fragments: input.fragments,
-                additionalMessages: input.additionalMessages,
-                originalFragments: input.originalFragments,
-                mutableFragmentIds: input.mutableFragmentIds,
-                maxInputChars: bodyLimit,
-            }, policy, {
-                stageId: prepared.stageId,
-                signal,
-                diagnostics: context.diagnostics,
-                compressors,
-                selectors,
-                // Read lazily so handlers see the live budget rather than the value at preparation.
-                remainingCalls: () => prepared.remainingCalls,
-                callModel: (options) => context.model.invoke({
-                    ...options,
-                    modelId: options.modelId ?? prepared.modelId,
+            return nativeSubFlowAsync(context, 'context', definition.id, async () => {
+                // The node timeout is an additional bound; parent cancellation still wins.
+                const signal = combineSignals(context.signal, AbortSignal.timeout(timeoutMs));
+                const prepared = selectPrepared
+                    ? selectPrepared(state, context)
+                    : context.model.prepare(typeof request === 'function' ? request(state, context) : request);
+                const input = synchronous(plan(state, context), 'Context plans must be synchronous');
+                // An empty measurement reports the allowance left after transport, instruction and schema
+                // overhead, so processing must fit inside whichever limit is tighter.
+                const overhead = prepared.measure([]);
+                const fullLimit = Math.min(input.maxInputChars, overhead.maxInputChars);
+                const bodyLimit = fullLimit;
+                breakWhile(bodyLimit < 1, 'No input capacity for context');
+                const work = beginContextProcessing({
+                    fragments: input.fragments,
+                    additionalMessages: input.additionalMessages,
+                    originalFragments: input.originalFragments,
+                    mutableFragmentIds: input.mutableFragmentIds,
+                    maxInputChars: bodyLimit,
+                }, policy, {
+                    stageId: prepared.stageId,
                     signal,
-                }),
-                ...(overhead.counterId
-                    ? {
-                        tokenBudget: {
-                            counterId: overhead.counterId,
-                            inputLimit: overhead.inputTokenLimit,
-                            measure: (messages) => prepared.measure(messages).inputTokens,
-                        },
-                    }
-                    : {}),
+                    diagnostics: context.diagnostics,
+                    compressors,
+                    selectors,
+                    // Read lazily so handlers see the live budget rather than the value at preparation.
+                    remainingCalls: () => prepared.remainingCalls,
+                    callModel: (options) => context.model.invoke({
+                        ...options,
+                        modelId: options.modelId ?? prepared.modelId,
+                        signal,
+                    }),
+                    ...(overhead.counterId
+                        ? {
+                            tokenBudget: {
+                                counterId: overhead.counterId,
+                                inputLimit: overhead.inputTokenLimit,
+                                measure: (messages) => prepared.measure(messages).inputTokens,
+                            },
+                        }
+                        : {}),
+                });
+                context.report({ payload: { phase: 'processing', fragmentCount: input.fragments.length } });
+                const result = await execute(work, prepared, fullLimit, state, context);
+                // Never report or commit a result produced after cancellation.
+                signal.throwIfAborted();
+                context.report({ payload: { phase: 'processed', report: work.report } });
+                return synchronous(update(result, state), 'Context node updates must be synchronous');
             });
-            context.report({ payload: { phase: 'processing', fragmentCount: input.fragments.length } });
-            const result = await execute(work, prepared, fullLimit, state, context);
-            // Never report or commit a result produced after cancellation.
-            signal.throwIfAborted();
-            context.report({ payload: { phase: 'processed', report: work.report } });
-            return synchronous(update(result, state), 'Context node updates must be synchronous');
         },
     };
 }

package/dist/esm/support/context/processing.js

@@ -11,6 +11,7 @@
  * `finishContextProcessing` (staged runs), the policy/reduction catalogs and the individual
  * validation, measurement and reduction helpers used by workflow nodes.
  */
+import { nativeSubFlowAsync } from '../../diagnostics/native-sub-flow.js';
 import { snapshotFragment, snapshotMessage } from './snapshot.js';
 import { auditContextChange as audit } from '../../context/audit.js';
 import { historyGroups, validateRecentHistory } from './history.js';
@@ -595,7 +596,9 @@ export function finishContextProcessing(state) {
  * @throws {BudgetError} When a handler exhausts its call allowance.
  */
 export async function processContext(plan, policy, ports) {
-    const state = beginContextProcessing(plan, policy, ports);
-    await contextPolicyCatalog[policy.mode].run(state);
-    return finishContextProcessing(state);
+    return nativeSubFlowAsync(ports, 'context', policy.mode, async () => {
+        const state = beginContextProcessing(plan, policy, ports);
+        await contextPolicyCatalog[policy.mode].run(state);
+        return finishContextProcessing(state);
+    });
 }

package/dist/esm/utils/invocation.d.ts

@@ -38,6 +38,7 @@ export declare function invocationResult<Value, Metadata extends InvocationMetad
  * @throws TypeError When the arity or the request shape is invalid.
  */
 export declare function toolInvocation(request: import('../structs/capabilities/tools.js').ToolInvocationRequest, arity: number): {
+    logger: import("../index.js").SubFlowLogger | undefined;
     toolId: string;
     input: unknown;
     diagnostics: import("../index.js").DiagnosticContext | undefined;

package/dist/esm/utils/invocation.js

@@ -41,6 +41,7 @@ export function toolInvocation(request, arity) {
         throw new TypeError('Use one tool request with toolId and input');
     }
     return {
+        logger: request.logger,
         toolId: request.toolId,
         input: request.input,
         diagnostics: request.diagnostics,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jangts/agent-core",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "type": "commonjs",
   "license": "Apache-2.0",
   "description": "Platform-independent agent runtime and configurable modules for evidence, delivery, policies and interactions",

package/dist/cjs/utils/debug.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.captureSubSteps = captureSubSteps;
-const sub_flow_js_1 = require("../diagnostics/sub-flow.js");
-const synchronous_js_1 = require("./synchronous.js");
-/**
- * Read the current sub-step log of one execution visit.
- *
- * A missing reader or a logger that yields nothing produces the empty shape, which
- * lets callers spread the result unconditionally. Failures are reported as one
- * dropped step instead of propagating, because diagnostics must not break execution.
- *
- * @param read - Getter for the current logger; omitted when the caller has no logger.
- * @param identity - Diagnostic identity copied onto each captured step.
- * @returns Frozen `subSteps`, the number of dropped steps and whether the log was truncated.
- */
-function captureSubSteps(read, identity) {
-    const empty = { subSteps: Object.freeze([]), subStepsDropped: 0, subStepsTruncated: false };
-    if (!read)
-        return empty;
-    try {
-        const logger = (0, synchronous_js_1.synchronous)(read(), 'Debug steps must be synchronous');
-        return logger === undefined
-            ? empty
-            : { ...empty, subSteps: (0, sub_flow_js_1.readSubFlowLogger)(logger, undefined, identity) };
-    }
-    catch {
-        return { ...empty, subStepsDropped: 1 };
-    }
-}

package/dist/esm/utils/debug.d.ts

@@ -1,27 +0,0 @@
-/**
- * Adapter between App-supplied debug loggers and the diagnostics pipeline.
- *
- * Sub-flow loggers are mutable, execution-owned objects. This module reads one at the
- * moment a diagnostic fact is built and converts it into a frozen array of steps, so
- * persisted observations never retain a live logger.
- *
- * Exports: `captureSubSteps`.
- */
-import type { SubFlowLogger } from '../structs/debug.js';
-import type { DiagnosticIdentity } from '../structs/diagnostics.js';
-/**
- * Read the current sub-step log of one execution visit.
- *
- * A missing reader or a logger that yields nothing produces the empty shape, which
- * lets callers spread the result unconditionally. Failures are reported as one
- * dropped step instead of propagating, because diagnostics must not break execution.
- *
- * @param read - Getter for the current logger; omitted when the caller has no logger.
- * @param identity - Diagnostic identity copied onto each captured step.
- * @returns Frozen `subSteps`, the number of dropped steps and whether the log was truncated.
- */
-export declare function captureSubSteps(read: (() => SubFlowLogger | undefined) | undefined, identity?: Readonly<DiagnosticIdentity>): {
-    subSteps: readonly Readonly<import("../index.js").RecordedSubStep>[];
-    subStepsDropped: number;
-    subStepsTruncated: boolean;
-};

package/dist/esm/utils/debug.js

@@ -1,27 +0,0 @@
-import { readSubFlowLogger } from '../diagnostics/sub-flow.js';
-import { synchronous } from './synchronous.js';
-/**
- * Read the current sub-step log of one execution visit.
- *
- * A missing reader or a logger that yields nothing produces the empty shape, which
- * lets callers spread the result unconditionally. Failures are reported as one
- * dropped step instead of propagating, because diagnostics must not break execution.
- *
- * @param read - Getter for the current logger; omitted when the caller has no logger.
- * @param identity - Diagnostic identity copied onto each captured step.
- * @returns Frozen `subSteps`, the number of dropped steps and whether the log was truncated.
- */
-export function captureSubSteps(read, identity) {
-    const empty = { subSteps: Object.freeze([]), subStepsDropped: 0, subStepsTruncated: false };
-    if (!read)
-        return empty;
-    try {
-        const logger = synchronous(read(), 'Debug steps must be synchronous');
-        return logger === undefined
-            ? empty
-            : { ...empty, subSteps: readSubFlowLogger(logger, undefined, identity) };
-    }
-    catch {
-        return { ...empty, subStepsDropped: 1 };
-    }
-}