@mcp-abap-adt/llm-agent-server-libs 18.1.0

package/README.md

@@ -0,0 +1,42 @@
+# @mcp-abap-adt/llm-agent-server-libs
+
+The SmartServer composition runtime as an **importable library**. It sits between the binary `@mcp-abap-adt/llm-agent-server` and the core `@mcp-abap-adt/llm-agent-libs`, so the SmartServer/coordinator composition can be reused in other projects without depending on the CLI/HTTP binary.
+
+## Top-level exports
+
+- `SmartServer` — HTTP-less SmartServer composition (config → built agent/coordinator).
+- `buildStepperRoot` / `buildFromComposition` — build a Stepper coordinator tree from a composition spec; `buildFromComposition` accepts a `makeRoleLlm(role)` callback so it is decoupled from the server's YAML LLM-map.
+- `StepperCoordinatorHandler` — the `coordinator` stage handler for the Stepper runtime.
+- Coordinator config parsing (`parseStepperCoordinatorConfig`, `StepperCompositionSpec`, `CompositionNode`, …), session stores, and `pipeline` wiring.
+
+### Pipeline builder-factories
+
+Each pipeline variant is a standalone, exportable factory implementing `IPipelineFactory<TConfig>` (from `@mcp-abap-adt/llm-agent`). `build(config, deps)` returns a `{ handler }` you register as the `coordinator` stage.
+
+| Factory | `kind` | Pipeline |
+|---|---|---|
+| `LinearFactory` | `linear` | linear tool-loop coordinator |
+| `DagFactory` | `dag` | DAG coordinator (parallel workers) |
+| `CyclicFactory` | `cyclic` | Stepper — planner `none` + cyclic-react executor |
+| `PlannedFactory` | `planned` | Stepper — LLM planner + cyclic-react executor |
+| `DeepStepperFactory` | `deep-stepper` | Stepper — LLM planner + recursive executor |
+
+```ts
+import { CyclicFactory } from '@mcp-abap-adt/llm-agent-server-libs';
+
+const { handler } = await new CyclicFactory().build(stepperConfig, {
+  makeRoleLlm: async (role) => myLlm, // 'planner' | 'executor' | 'finalizer' | 'reviewer' | 'evaluator' | 'classifier'
+  callMcp,
+  knowledgeRagFor,
+  toolsRag,
+  mintStepperId: () => crypto.randomUUID(),
+  mintTurnId: () => crypto.randomUUID(),
+});
+registry.set('coordinator', handler);
+```
+
+See `docs/INTEGRATION.md` (“Reusing pipeline builder-factories”) for the full example.
+
+## Dependencies
+
+Depends on `@mcp-abap-adt/llm-agent`, `@mcp-abap-adt/llm-agent-libs`, `@mcp-abap-adt/llm-agent-mcp`, `@mcp-abap-adt/llm-agent-rag`. The binary `@mcp-abap-adt/llm-agent-server` depends on this package.

package/dist/factories/cyclic-factory.d.ts

@@ -0,0 +1,48 @@
+import type { BuiltCoordinator, IKnowledgeRagHandle, IPipelineFactory, IStepper, IToolsRagHandle, LlmCallEntry, PipelineFactoryDepsBase } from '@mcp-abap-adt/llm-agent';
+import { type StepperCompositionSpec } from '../smart-agent/build-stepper-root.js';
+/**
+ * Runtime dependencies for the Stepper builder-factories. Richer than
+ * {@link PipelineFactoryDepsBase}: the Stepper coordinator handler also needs the
+ * per-session knowledge RAG factory, the shared tools RAG handle, ID minters,
+ * and (optionally) a subagent catalog / pre-built child Stepper registry and a
+ * per-call usage logger.
+ */
+export interface StepperFactoryDeps extends PipelineFactoryDepsBase {
+    /** Per-sessionId knowledge RAG factory (run-time handler dep). */
+    knowledgeRagFor: (sessionId: string) => Promise<IKnowledgeRagHandle>;
+    /** Shared tools RAG handle (run-time handler dep). */
+    toolsRag: IToolsRagHandle;
+    /** Monotonically-unique stepper-ID minter. */
+    mintStepperId: () => string;
+    /** Per-request turn-ID minter. */
+    mintTurnId: () => string;
+    /** Declared subagents (name + description) for deep-stepper recursion. */
+    subagents?: ReadonlyArray<{
+        name: string;
+        description?: string;
+    }>;
+    /** Pre-built named registry of child Steppers (DI/test override). */
+    registry?: ReadonlyMap<string, IStepper>;
+    /** Optional per-role LLM usage logger. */
+    logLlmCall?: (entry: LlmCallEntry) => void;
+}
+/**
+ * The caller supplies everything in the spec EXCEPT the {planner,executor}
+ * preset, which each factory bakes in.
+ */
+export type StepperFactoryConfig = Omit<StepperCompositionSpec, 'planner' | 'executor'>;
+/**
+ * Shared builder: wires a {@link StepperCoordinatorHandler} whose `buildBuilt`
+ * defers to {@link buildFromComposition} with the role-LLM resolution path.
+ * `knowledgeRagFor`/`toolsRag` are HANDLER deps used at run time, not build deps.
+ */
+export declare function buildStepperCoordinator(spec: StepperCompositionSpec, deps: StepperFactoryDeps): Promise<BuiltCoordinator>;
+/**
+ * Cyclic Stepper variant: no planner, a single cyclic-ReAct executor loop.
+ * Preset: `{ planner: 'none', executor: 'cyclic-react' }`.
+ */
+export declare class CyclicFactory implements IPipelineFactory<StepperFactoryConfig> {
+    readonly kind: "cyclic";
+    build(config: StepperFactoryConfig, deps: StepperFactoryDeps): Promise<BuiltCoordinator>;
+}
+//# sourceMappingURL=cyclic-factory.d.ts.map

package/dist/factories/cyclic-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclic-factory.d.ts","sourceRoot":"","sources":["../../src/factories/cyclic-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,gBAAgB,EAChB,QAAQ,EACR,eAAe,EACf,YAAY,EACZ,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,sCAAsC,CAAC;AAG9C;;;;;;GAMG;AACH,MAAM,WAAW,kBAAmB,SAAQ,uBAAuB;IACjE,kEAAkE;IAClE,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACrE,sDAAsD;IACtD,QAAQ,EAAE,eAAe,CAAC;IAC1B,8CAA8C;IAC9C,aAAa,EAAE,MAAM,MAAM,CAAC;IAC5B,kCAAkC;IAClC,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qEAAqE;IACrE,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACzC,0CAA0C;IAC1C,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;CAC5C;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,sBAAsB,EACtB,SAAS,GAAG,UAAU,CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,sBAAsB,EAC5B,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAiB3B;AAED;;;GAGG;AACH,qBAAa,aAAc,YAAW,gBAAgB,CAAC,oBAAoB,CAAC;IAC1E,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAElC,KAAK,CACH,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,gBAAgB,CAAC;CAM7B"}

package/dist/factories/cyclic-factory.js

@@ -0,0 +1,35 @@
+import { buildFromComposition, } from '../smart-agent/build-stepper-root.js';
+import { StepperCoordinatorHandler } from '../smart-agent/stepper-coordinator-handler.js';
+/**
+ * Shared builder: wires a {@link StepperCoordinatorHandler} whose `buildBuilt`
+ * defers to {@link buildFromComposition} with the role-LLM resolution path.
+ * `knowledgeRagFor`/`toolsRag` are HANDLER deps used at run time, not build deps.
+ */
+export async function buildStepperCoordinator(spec, deps) {
+    const handler = new StepperCoordinatorHandler({
+        buildBuilt: async (_ctx, logLlmCall) => buildFromComposition(spec, {
+            makeRoleLlm: deps.makeRoleLlm,
+            callMcp: deps.callMcp,
+            mintStepperId: deps.mintStepperId,
+            registry: deps.registry ?? new Map(),
+            logLlmCall,
+            ...(deps.subagents ? { subagents: deps.subagents } : {}),
+        }),
+        knowledgeRagFor: deps.knowledgeRagFor,
+        toolsRag: deps.toolsRag,
+        mintStepperId: deps.mintStepperId,
+        mintTurnId: deps.mintTurnId,
+    });
+    return { handler };
+}
+/**
+ * Cyclic Stepper variant: no planner, a single cyclic-ReAct executor loop.
+ * Preset: `{ planner: 'none', executor: 'cyclic-react' }`.
+ */
+export class CyclicFactory {
+    kind = 'cyclic';
+    build(config, deps) {
+        return buildStepperCoordinator({ ...config, planner: 'none', executor: 'cyclic-react' }, deps);
+    }
+}
+//# sourceMappingURL=cyclic-factory.js.map

package/dist/factories/cyclic-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cyclic-factory.js","sourceRoot":"","sources":["../../src/factories/cyclic-factory.ts"],"names":[],"mappings":"AASA,OAAO,EACL,oBAAoB,GAErB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAmC1F;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,IAA4B,EAC5B,IAAwB;IAExB,MAAM,OAAO,GAAG,IAAI,yBAAyB,CAAC;QAC5C,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,CACrC,oBAAoB,CAAC,IAAI,EAAE;YACzB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,IAAI,GAAG,EAAE;YACpC,UAAU;YACV,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACzD,CAAC;QACJ,eAAe,EAAE,IAAI,CAAC,eAAe;QACrC,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,UAAU,EAAE,IAAI,CAAC,UAAU;KAC5B,CAAC,CAAC;IACH,OAAO,EAAE,OAAO,EAAE,CAAC;AACrB,CAAC;AAED;;;GAGG;AACH,MAAM,OAAO,aAAa;IACf,IAAI,GAAG,QAAiB,CAAC;IAElC,KAAK,CACH,MAA4B,EAC5B,IAAwB;QAExB,OAAO,uBAAuB,CAC5B,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,EACxD,IAAI,CACL,CAAC;IACJ,CAAC;CACF"}

package/dist/factories/dag-factory.d.ts

@@ -0,0 +1,13 @@
+import type { BuiltCoordinator, IPipelineFactory, PipelineFactoryDepsBase } from '@mcp-abap-adt/llm-agent';
+import { type DagCoordinatorHandlerDeps } from '@mcp-abap-adt/llm-agent-libs';
+/**
+ * Builder-factory that wraps the existing {@link DagCoordinatorHandler}.
+ * The `config` parameter IS the fully-formed handler deps — the factory
+ * simply constructs the handler and returns it.  The base pipeline deps
+ * (`_deps`) are unused because DAG wiring is captured entirely in `config`.
+ */
+export declare class DagFactory implements IPipelineFactory<DagCoordinatorHandlerDeps> {
+    readonly kind: "dag";
+    build(config: DagCoordinatorHandlerDeps, _deps: PipelineFactoryDepsBase): Promise<BuiltCoordinator>;
+}
+//# sourceMappingURL=dag-factory.d.ts.map

package/dist/factories/dag-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag-factory.d.ts","sourceRoot":"","sources":["../../src/factories/dag-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,8BAA8B,CAAC;AAEtC;;;;;GAKG;AACH,qBAAa,UAAW,YAAW,gBAAgB,CAAC,yBAAyB,CAAC;IAC5E,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAEzB,KAAK,CACT,MAAM,EAAE,yBAAyB,EACjC,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,gBAAgB,CAAC;CAG7B"}

package/dist/factories/dag-factory.js

@@ -0,0 +1,14 @@
+import { DagCoordinatorHandler, } from '@mcp-abap-adt/llm-agent-libs';
+/**
+ * Builder-factory that wraps the existing {@link DagCoordinatorHandler}.
+ * The `config` parameter IS the fully-formed handler deps — the factory
+ * simply constructs the handler and returns it.  The base pipeline deps
+ * (`_deps`) are unused because DAG wiring is captured entirely in `config`.
+ */
+export class DagFactory {
+    kind = 'dag';
+    async build(config, _deps) {
+        return { handler: new DagCoordinatorHandler(config) };
+    }
+}
+//# sourceMappingURL=dag-factory.js.map

package/dist/factories/dag-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag-factory.js","sourceRoot":"","sources":["../../src/factories/dag-factory.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,qBAAqB,GAEtB,MAAM,8BAA8B,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,OAAO,UAAU;IACZ,IAAI,GAAG,KAAc,CAAC;IAE/B,KAAK,CAAC,KAAK,CACT,MAAiC,EACjC,KAA8B;QAE9B,OAAO,EAAE,OAAO,EAAE,IAAI,qBAAqB,CAAC,MAAM,CAAC,EAAE,CAAC;IACxD,CAAC;CACF"}

package/dist/factories/deep-stepper-factory.d.ts

@@ -0,0 +1,12 @@
+import type { BuiltCoordinator, IPipelineFactory } from '@mcp-abap-adt/llm-agent';
+import { type StepperFactoryConfig, type StepperFactoryDeps } from './cyclic-factory.js';
+/**
+ * Deep-stepper variant: an LLM planner decomposes the goal and the recursive
+ * executor delegates sub-goals to child Steppers (subagents).
+ * Preset: `{ planner: 'llm', executor: 'recursive' }`.
+ */
+export declare class DeepStepperFactory implements IPipelineFactory<StepperFactoryConfig> {
+    readonly kind: "deep-stepper";
+    build(config: StepperFactoryConfig, deps: StepperFactoryDeps): Promise<BuiltCoordinator>;
+}
+//# sourceMappingURL=deep-stepper-factory.d.ts.map

package/dist/factories/deep-stepper-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-stepper-factory.d.ts","sourceRoot":"","sources":["../../src/factories/deep-stepper-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,qBAAa,kBACX,YAAW,gBAAgB,CAAC,oBAAoB,CAAC;IAEjD,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAU;IAExC,KAAK,CACH,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,gBAAgB,CAAC;CAM7B"}

package/dist/factories/deep-stepper-factory.js

@@ -0,0 +1,13 @@
+import { buildStepperCoordinator, } from './cyclic-factory.js';
+/**
+ * Deep-stepper variant: an LLM planner decomposes the goal and the recursive
+ * executor delegates sub-goals to child Steppers (subagents).
+ * Preset: `{ planner: 'llm', executor: 'recursive' }`.
+ */
+export class DeepStepperFactory {
+    kind = 'deep-stepper';
+    build(config, deps) {
+        return buildStepperCoordinator({ ...config, planner: 'llm', executor: 'recursive' }, deps);
+    }
+}
+//# sourceMappingURL=deep-stepper-factory.js.map

package/dist/factories/deep-stepper-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-stepper-factory.js","sourceRoot":"","sources":["../../src/factories/deep-stepper-factory.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,uBAAuB,GAGxB,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,MAAM,OAAO,kBAAkB;IAGpB,IAAI,GAAG,cAAuB,CAAC;IAExC,KAAK,CACH,MAA4B,EAC5B,IAAwB;QAExB,OAAO,uBAAuB,CAC5B,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,EACpD,IAAI,CACL,CAAC;IACJ,CAAC;CACF"}

package/dist/factories/index.d.ts

@@ -0,0 +1,7 @@
+export type { StepperFactoryConfig, StepperFactoryDeps, } from './cyclic-factory.js';
+export { buildStepperCoordinator, CyclicFactory } from './cyclic-factory.js';
+export { DagFactory } from './dag-factory.js';
+export { DeepStepperFactory } from './deep-stepper-factory.js';
+export { LinearFactory } from './linear-factory.js';
+export { PlannedFactory } from './planned-factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/factories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factories/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/factories/index.js

@@ -0,0 +1,6 @@
+export { buildStepperCoordinator, CyclicFactory } from './cyclic-factory.js';
+export { DagFactory } from './dag-factory.js';
+export { DeepStepperFactory } from './deep-stepper-factory.js';
+export { LinearFactory } from './linear-factory.js';
+export { PlannedFactory } from './planned-factory.js';
+//# sourceMappingURL=index.js.map

package/dist/factories/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/factories/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/factories/linear-factory.d.ts

@@ -0,0 +1,13 @@
+import type { BuiltCoordinator, IPipelineFactory, PipelineFactoryDepsBase } from '@mcp-abap-adt/llm-agent';
+import { type CoordinatorHandlerDeps } from '@mcp-abap-adt/llm-agent-libs';
+/**
+ * Builder-factory that wraps the existing linear {@link CoordinatorHandler}.
+ * The `config` parameter IS the fully-formed handler deps — the factory
+ * simply constructs the handler and returns it.  The base pipeline deps
+ * (`_deps`) are unused because linear wiring is captured entirely in `config`.
+ */
+export declare class LinearFactory implements IPipelineFactory<CoordinatorHandlerDeps> {
+    readonly kind: "linear";
+    build(config: CoordinatorHandlerDeps, _deps: PipelineFactoryDepsBase): Promise<BuiltCoordinator>;
+}
+//# sourceMappingURL=linear-factory.d.ts.map

package/dist/factories/linear-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-factory.d.ts","sourceRoot":"","sources":["../../src/factories/linear-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,8BAA8B,CAAC;AAEtC;;;;;GAKG;AACH,qBAAa,aAAc,YAAW,gBAAgB,CAAC,sBAAsB,CAAC;IAC5E,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;IAE5B,KAAK,CACT,MAAM,EAAE,sBAAsB,EAC9B,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,gBAAgB,CAAC;CAG7B"}

package/dist/factories/linear-factory.js

@@ -0,0 +1,14 @@
+import { CoordinatorHandler, } from '@mcp-abap-adt/llm-agent-libs';
+/**
+ * Builder-factory that wraps the existing linear {@link CoordinatorHandler}.
+ * The `config` parameter IS the fully-formed handler deps — the factory
+ * simply constructs the handler and returns it.  The base pipeline deps
+ * (`_deps`) are unused because linear wiring is captured entirely in `config`.
+ */
+export class LinearFactory {
+    kind = 'linear';
+    async build(config, _deps) {
+        return { handler: new CoordinatorHandler(config) };
+    }
+}
+//# sourceMappingURL=linear-factory.js.map

package/dist/factories/linear-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-factory.js","sourceRoot":"","sources":["../../src/factories/linear-factory.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,kBAAkB,GAEnB,MAAM,8BAA8B,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,OAAO,aAAa;IACf,IAAI,GAAG,QAAiB,CAAC;IAElC,KAAK,CAAC,KAAK,CACT,MAA8B,EAC9B,KAA8B;QAE9B,OAAO,EAAE,OAAO,EAAE,IAAI,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;IACrD,CAAC;CACF"}

package/dist/factories/planned-factory.d.ts

@@ -0,0 +1,12 @@
+import type { BuiltCoordinator, IPipelineFactory } from '@mcp-abap-adt/llm-agent';
+import { type StepperFactoryConfig, type StepperFactoryDeps } from './cyclic-factory.js';
+/**
+ * Planned Stepper variant: an LLM planner decomposes the goal, then a
+ * cyclic-ReAct executor runs each step.
+ * Preset: `{ planner: 'llm', executor: 'cyclic-react' }`.
+ */
+export declare class PlannedFactory implements IPipelineFactory<StepperFactoryConfig> {
+    readonly kind: "planned";
+    build(config: StepperFactoryConfig, deps: StepperFactoryDeps): Promise<BuiltCoordinator>;
+}
+//# sourceMappingURL=planned-factory.d.ts.map

package/dist/factories/planned-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planned-factory.d.ts","sourceRoot":"","sources":["../../src/factories/planned-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,qBAAa,cAAe,YAAW,gBAAgB,CAAC,oBAAoB,CAAC;IAC3E,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAU;IAEnC,KAAK,CACH,MAAM,EAAE,oBAAoB,EAC5B,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC,gBAAgB,CAAC;CAM7B"}

package/dist/factories/planned-factory.js

@@ -0,0 +1,13 @@
+import { buildStepperCoordinator, } from './cyclic-factory.js';
+/**
+ * Planned Stepper variant: an LLM planner decomposes the goal, then a
+ * cyclic-ReAct executor runs each step.
+ * Preset: `{ planner: 'llm', executor: 'cyclic-react' }`.
+ */
+export class PlannedFactory {
+    kind = 'planned';
+    build(config, deps) {
+        return buildStepperCoordinator({ ...config, planner: 'llm', executor: 'cyclic-react' }, deps);
+    }
+}
+//# sourceMappingURL=planned-factory.js.map

package/dist/factories/planned-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planned-factory.js","sourceRoot":"","sources":["../../src/factories/planned-factory.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,uBAAuB,GAGxB,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,MAAM,OAAO,cAAc;IAChB,IAAI,GAAG,SAAkB,CAAC;IAEnC,KAAK,CACH,MAA4B,EAC5B,IAAwB;QAExB,OAAO,uBAAuB,CAC5B,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,EACvD,IAAI,CACL,CAAC;IACJ,CAAC;CACF"}

package/dist/generated/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_VERSION = "18.1.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/generated/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/generated/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,WAAW,CAAC"}

package/dist/generated/version.js

@@ -0,0 +1,3 @@
+// Auto-generated by scripts/generate-version.js — do not edit
+export const PACKAGE_VERSION = '18.1.0';
+//# sourceMappingURL=version.js.map

package/dist/generated/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/generated/version.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './factories/index.js';
+export * from './smart-agent/build-dag-coordinator-deps.js';
+export * from './smart-agent/build-stepper-root.js';
+export * from './smart-agent/config.js';
+export * from './smart-agent/jsonl-knowledge-backend.js';
+export * from './smart-agent/pipeline.js';
+export * from './smart-agent/resolve-agent-embedder.js';
+export * from './smart-agent/session-identity-resolver.js';
+export * from './smart-agent/session-meta-store.js';
+export * from './smart-agent/smart-server.js';
+export * from './smart-agent/stepper-coordinator-handler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,cAAc,yBAAyB,CAAC;AACxC,cAAc,0CAA0C,CAAC;AACzD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qCAAqC,CAAC;AACpD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8CAA8C,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+export * from './factories/index.js';
+export * from './smart-agent/build-dag-coordinator-deps.js';
+export * from './smart-agent/build-stepper-root.js';
+export * from './smart-agent/config.js';
+export * from './smart-agent/jsonl-knowledge-backend.js';
+export * from './smart-agent/pipeline.js';
+export * from './smart-agent/resolve-agent-embedder.js';
+export * from './smart-agent/session-identity-resolver.js';
+export * from './smart-agent/session-meta-store.js';
+export * from './smart-agent/smart-server.js';
+export * from './smart-agent/stepper-coordinator-handler.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,qCAAqC,CAAC;AACpD,cAAc,yBAAyB,CAAC;AACxC,cAAc,0CAA0C,CAAC;AACzD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yCAAyC,CAAC;AACxD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qCAAqC,CAAC;AACpD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8CAA8C,CAAC"}

package/dist/smart-agent/build-dag-coordinator-deps.d.ts

@@ -0,0 +1,34 @@
+import type { ILlm, ISubAgent } from '@mcp-abap-adt/llm-agent';
+import type { DagCoordinatorHandlerDeps } from '@mcp-abap-adt/llm-agent-libs';
+import { type NormalizedLlmMap } from './config.js';
+import type { SmartServerLlmConfig } from './smart-server.js';
+export interface BuildDagCoordinatorDepsInput {
+    coordCfg: Record<string, unknown> | undefined;
+    llmMap: NormalizedLlmMap | undefined;
+    /** Adapted from `pipeline.llm.main` (already shape-normalized to
+     *  SmartServerLlmConfig: `{ provider, apiKey, url: baseURL, model,
+     *  temperature }`). When set, used as the final fallback in the
+     *  role-resolution chain map[name] → map.main → pipelineFallback. */
+    pipelineFallback: SmartServerLlmConfig | undefined;
+    mainLlm: ILlm;
+    helperLlm: ILlm | undefined;
+    mainTemp: number;
+    registry: ReadonlyMap<string, ISubAgent>;
+    makeLlm: (config: SmartServerLlmConfig) => Promise<ILlm>;
+    warn: (msg: string) => void;
+}
+export type BuiltDagCoordinatorDeps = Omit<DagCoordinatorHandlerDeps, 'workers'> & {
+    workers: Map<string, ISubAgent>;
+    oracleName?: string;
+};
+/**
+ * Assemble the full deps record for `withDagCoordinator`. Returns
+ * `undefined` when the YAML does not declare a DAG coordinator (no
+ * `planner` block), so the caller can branch.
+ *
+ * Roles resolve their LLM via the chain:
+ *   resolveLlmConfig(llmMap, name, pipelineFallback)
+ *   → top-level llm.<name> → llm.main → pipelineFallback (pipeline.llm.main)
+ */
+export declare function buildDagCoordinatorDeps(input: BuildDagCoordinatorDepsInput): Promise<BuiltDagCoordinatorDeps | undefined>;
+//# sourceMappingURL=build-dag-coordinator-deps.d.ts.map

package/dist/smart-agent/build-dag-coordinator-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-dag-coordinator-deps.d.ts","sourceRoot":"","sources":["../../src/smart-agent/build-dag-coordinator-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,IAAI,EAEJ,SAAS,EACV,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AAS9E,OAAO,EAEL,KAAK,gBAAgB,EAKtB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAC9C,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACrC;;;yEAGqE;IACrE,gBAAgB,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACnD,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE,IAAI,GAAG,SAAS,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACzC,OAAO,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B;AAED,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACxC,yBAAyB,EACzB,SAAS,CACV,GAAG;IACF,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,uBAAuB,GAAG,SAAS,CAAC,CA0I9C"}

package/dist/smart-agent/build-dag-coordinator-deps.js

@@ -0,0 +1,107 @@
+import { AbortErrorStrategy, DagPlanInterpreter, LlmDagPlanner, LlmReviewStrategy, ReplanErrorStrategy, SubAgentStateOracle, } from '@mcp-abap-adt/llm-agent-libs';
+import { buildFinalizer, resolveCoordinatorActivation, resolveLlmConfig, resolveLlmConfigStrict, resolveReviewerLlmName, } from './config.js';
+/**
+ * Assemble the full deps record for `withDagCoordinator`. Returns
+ * `undefined` when the YAML does not declare a DAG coordinator (no
+ * `planner` block), so the caller can branch.
+ *
+ * Roles resolve their LLM via the chain:
+ *   resolveLlmConfig(llmMap, name, pipelineFallback)
+ *   → top-level llm.<name> → llm.main → pipelineFallback (pipeline.llm.main)
+ */
+export async function buildDagCoordinatorDeps(input) {
+    const { coordCfg, llmMap, pipelineFallback, mainLlm, helperLlm, mainTemp, registry, makeLlm, warn, } = input;
+    if (!coordCfg || coordCfg.planner === undefined)
+        return undefined;
+    // ---- Role LLM resolver -----------------------------------------------
+    // Priority chain:
+    //   1. map[name] — explicit named entry in the top-level llm: block
+    //   2. 'helper' | 'planner' alias — route to the prebuilt helperLlm
+    //   3. pipelineFallback (pipeline.llm.main) — last resort
+    //   4. fallbackPrebuilt (mainLlm) — when nothing else resolves
+    const resolveRoleLlm = async (name, fallbackPrebuilt = mainLlm) => {
+        // 1. Explicit map[name] — use it (strict: no main fallback here).
+        const strict = resolveLlmConfigStrict(llmMap, name);
+        if (strict) {
+            return makeLlm({
+                ...strict,
+                temperature: Number(strict.temperature ?? mainTemp),
+            });
+        }
+        // 2. 'helper' | 'planner' alias → reuse prebuilt helperLlm.
+        if (name === 'helper' || name === 'planner') {
+            return helperLlm ?? fallbackPrebuilt;
+        }
+        // 3. Unknown name → final fallback chain via resolveLlmConfig (map.main → pipelineFallback).
+        if (name) {
+            const fb = resolveLlmConfig(llmMap, name, pipelineFallback);
+            if (fb) {
+                return makeLlm({
+                    ...fb,
+                    temperature: Number(fb.temperature ?? mainTemp),
+                });
+            }
+        }
+        // 4. No name at all → fallbackPrebuilt (mainLlm by default).
+        return fallbackPrebuilt;
+    };
+    // ---- Planner ----------------------------------------------------------
+    const plannerBlock = coordCfg.planner;
+    const plannerLlm = await resolveRoleLlm(plannerBlock?.plannerLlm);
+    const planner = new LlmDagPlanner(plannerLlm);
+    // ---- Reviewer (optional) ---------------------------------------------
+    let reviewer;
+    if (coordCfg.reviewer !== undefined) {
+        const reviewerBlock = coordCfg.reviewer;
+        const reviewerName = resolveReviewerLlmName(reviewerBlock, warn);
+        const reviewerLlm = await resolveRoleLlm(reviewerName);
+        reviewer = new LlmReviewStrategy(reviewerLlm);
+    }
+    // ---- Interpreter, workers, oracle, activation, error strategy --------
+    const interpreter = new DagPlanInterpreter();
+    const oracleName = coordCfg.stateOracle;
+    let rawOracle;
+    if (oracleName) {
+        rawOracle = registry.get(oracleName);
+        if (!rawOracle) {
+            throw new Error(`coordinator.stateOracle '${oracleName}' is not a declared subagent`);
+        }
+    }
+    const workers = new Map([...registry].filter(([name]) => name !== oracleName));
+    if (workers.size === 0) {
+        throw new Error('coordinator.planner is set (DAG mode) but no workers are configured. ' +
+            'Add at least one entry under the top-level `subagents:` block.');
+    }
+    const activation = resolveCoordinatorActivation((coordCfg.activation ?? 'explicit'));
+    let errorStrategy;
+    const esCfg = coordCfg.errorStrategy;
+    if (esCfg?.type === 'replan') {
+        errorStrategy = new ReplanErrorStrategy(planner, esCfg.maxReplans);
+    }
+    else if (esCfg?.type === 'abort') {
+        errorStrategy = new AbortErrorStrategy();
+    }
+    // ---- Finalizer --------------------------------------------------------
+    const finalizer = await buildFinalizer(coordCfg.finalizer, llmMap, pipelineFallback, async (lc) => makeLlm({
+        ...lc,
+        temperature: Number(lc.temperature ?? mainTemp),
+    }));
+    // ---- Oracle wrap ------------------------------------------------------
+    const stateOracle = rawOracle
+        ? new SubAgentStateOracle(rawOracle)
+        : undefined;
+    void mainLlm;
+    return {
+        planner,
+        interpreter,
+        workers,
+        activation,
+        reviewer,
+        errorStrategy,
+        stateOracle,
+        finalizer,
+        maxRoundTrips: coordCfg.maxRoundTrips,
+        oracleName,
+    };
+}
+//# sourceMappingURL=build-dag-coordinator-deps.js.map

package/dist/smart-agent/build-dag-coordinator-deps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-dag-coordinator-deps.js","sourceRoot":"","sources":["../../src/smart-agent/build-dag-coordinator-deps.ts"],"names":[],"mappings":"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"}

package/dist/smart-agent/build-stepper-root.d.ts

@@ -0,0 +1,110 @@
+import { type IKnowledgeRagHandle, type ILlm, type IStepper, type ITaskFormalizer, type LlmCallEntry, TokenLedger } from '@mcp-abap-adt/llm-agent';
+import { RootFinalizer, Stepper } from '@mcp-abap-adt/llm-agent-libs';
+import { type NormalizedLlmMap, type StepperCompositionSpec, type StepperCoordinatorConfig } from './config.js';
+import type { SmartServerLlmConfig } from './smart-server.js';
+export interface BuildStepperRootInput {
+    /** Raw coordinator config object (e.g. the `coordinator:` YAML block). */
+    coordCfg: Record<string, unknown>;
+    /**
+     * Pre-built named registry of subagent Steppers — DI/test override for
+     * deep-stepper mode. When non-empty it is used as childSteppers verbatim;
+     * when empty, child Steppers are built from `subagents` (the normal path).
+     */
+    registry: ReadonlyMap<string, IStepper>;
+    /**
+     * Declared subagents (name + description) from the `subagents:` YAML block.
+     * In deep-stepper mode each becomes a recursive child Stepper sharing this
+     * run's planner/executor/reviewer/ledger, and is advertised to the planner so
+     * it can delegate sub-goals via a node's `agent`. Ignored in other modes.
+     */
+    subagents?: ReadonlyArray<{
+        name: string;
+        description?: string;
+    }>;
+    /** Factory to build an ILlm from a config; used for all roles. */
+    makeLlm: (config: SmartServerLlmConfig) => Promise<ILlm>;
+    /** Per-sessionId knowledge RAG factory. */
+    knowledgeRagFor: (sessionId: string) => IKnowledgeRagHandle;
+    /** Shared tools RAG handle. */
+    toolsRag: import('@mcp-abap-adt/llm-agent').IToolsRagHandle;
+    /** MCP tool invoker. */
+    callMcp: (name: string, args: unknown, signal?: AbortSignal) => Promise<string>;
+    /** Monotonically-unique stepper-ID minter. */
+    mintStepperId: () => string;
+    /**
+     * Normalized per-role LLM map (top-level `llm:` block after normalization).
+     * Roles resolve via: llmMap[role] → llmMap.main → pipelineFallback.
+     * When both are undefined, roles fall back to a stub (test path).
+     */
+    llmMap?: NormalizedLlmMap;
+    /**
+     * Pipeline fallback config (`pipeline.llm.main`). Used as last resort when
+     * a role is absent from llmMap.
+     */
+    pipelineFallback?: SmartServerLlmConfig;
+    /**
+     * Optional usage logger. When supplied, every per-role LLM call is logged
+     * via a LoggingLlm decorator so byComponent is populated in requestLogger.
+     * Matches IRequestLogger.logLlmCall(entry) — pass a bound wrapper that
+     * injects the traceId as requestId.
+     */
+    logLlmCall?: (entry: LlmCallEntry) => void;
+}
+export interface BuiltStepperRoot {
+    rootStepper: Stepper;
+    finalizer: RootFinalizer;
+    budget: {
+        depthRemaining: number;
+        tokens: TokenLedger;
+    };
+    maxParallelSteps: number;
+    /**
+     * Present only when `coordinator.formalizeTask` is enabled. The handler calls
+     * it ONCE on the raw prompt and threads the resulting TaskSpec into
+     * rootStepper.run. Absent → no formalization (behaves as before).
+     */
+    taskFormalizer?: ITaskFormalizer;
+}
+export type { CompositionNode, StepperCompositionSpec } from './config.js';
+/** Build-time dependencies (everything not part of the composition itself). */
+export interface BuildFromCompositionDeps {
+    /**
+     * Factory to build an ILlm from a server config. Used by the legacy
+     * llmMap/pipelineFallback resolution path. Optional when makeRoleLlm is
+     * supplied instead.
+     */
+    makeLlm?: (config: SmartServerLlmConfig) => Promise<ILlm>;
+    callMcp: (name: string, args: unknown, signal?: AbortSignal) => Promise<string>;
+    mintStepperId: () => string;
+    /** Optional per-role LLM map (legacy server path). */
+    llmMap?: NormalizedLlmMap;
+    /** Pipeline fallback config (legacy server path). */
+    pipelineFallback?: SmartServerLlmConfig;
+    logLlmCall?: (entry: LlmCallEntry) => void;
+    subagents?: ReadonlyArray<{
+        name: string;
+        description?: string;
+    }>;
+    registry: ReadonlyMap<string, IStepper>;
+    /**
+     * When present, supersedes llmMap/makeLlm resolution: resolve a role's LLM
+     * directly. Enables config-decoupled pipeline builder-factories that live in a
+     * library without depending on SmartServerLlmConfig.
+     */
+    makeRoleLlm?: (role: string) => Promise<ILlm>;
+}
+/** Map a parsed coordinator config to the front-end-agnostic composition spec. */
+export declare function toCompositionSpec(config: StepperCoordinatorConfig): StepperCompositionSpec;
+/**
+ * yaml front-end: parse the raw coordinator config block → composition spec →
+ * build. Thin wrapper over {@link buildFromComposition}; a code builder can call
+ * buildFromComposition directly with a spec it constructs itself (parity).
+ */
+export declare function buildStepperRoot(input: BuildStepperRootInput): Promise<BuiltStepperRoot>;
+/**
+ * Build the root Stepper + finalizer from a front-end-agnostic composition spec.
+ * The yaml path reaches here via buildStepperRoot; a code builder can call this
+ * directly. Each role LLM resolves via llmMap[role] → llmMap.main → fallback.
+ */
+export declare function buildFromComposition(spec: StepperCompositionSpec, deps: BuildFromCompositionDeps): Promise<BuiltStepperRoot>;
+//# sourceMappingURL=build-stepper-root.d.ts.map