@zimtsui/typechat 0.0.98 → 0.0.99

package/build/engine/parts-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parts-validator.js","sourceRoot":"","sources":["../../src/engine/parts-validator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAI/C,MAAM,OAAO,cAAc;IAKhB,QAAQ,CACX,OAAiC;QAEjC,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,CAAA,CAAC;;YAAM,MAAM,IAAI,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAC/E,IAAI,WAAW,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAAE,MAAM,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC;IAC3E,CAAC;CAEJ"}

package/build/engine/recoverable.d.ts

@@ -0,0 +1,13 @@
+import { Function } from '../function.ts';
+import { type InferenceContext } from '../inference-context.ts';
+import { Session } from './session.ts';
+import { RoleMessage } from './message.ts';
+import { Verbatim } from '../verbatim.ts';
+export declare class Recoverable<in out fdu extends Function.Decl.Proto, in out vdu extends Verbatim.Decl.Proto> extends SyntaxError {
+    protected response: RoleMessage.Ai<fdu, vdu>;
+    protected rejection: RoleMessage.User<never>;
+    constructor(response: RoleMessage.Ai<fdu, vdu>, rejection: RoleMessage.User<never>, ...rest: ConstructorParameters<typeof SyntaxError>);
+    resume(): RoleMessage.Ai<fdu, vdu>;
+    recover(): RoleMessage.User<never>;
+    static recover<fdu extends Function.Decl.Proto, vdu extends Verbatim.Decl.Proto>(wfctx: InferenceContext, session: Session<fdu, vdu>, next: () => Promise<RoleMessage.Ai<fdu, vdu>>): Promise<RoleMessage.Ai<fdu, vdu>>;
+}

package/build/engine/recoverable.js

@@ -0,0 +1,29 @@
+export class Recoverable extends SyntaxError {
+    response;
+    rejection;
+    constructor(response, rejection, ...rest) {
+        super(...rest);
+        this.response = response;
+        this.rejection = rejection;
+    }
+    resume() {
+        return this.response;
+    }
+    recover() {
+        return this.rejection;
+    }
+    static async recover(wfctx, session, next) {
+        try {
+            return await next();
+        }
+        catch (e) {
+            if (e instanceof Recoverable) { }
+            else
+                throw e;
+            const recoverable = e;
+            session.chatMessages.push(recoverable.resume(), recoverable.recover());
+            throw e;
+        }
+    }
+}
+//# sourceMappingURL=recoverable.js.map

package/build/engine/recoverable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recoverable.js","sourceRoot":"","sources":["../../src/engine/recoverable.ts"],"names":[],"mappings":"AAOA,MAAM,OAAO,WAGX,SAAQ,WAAW;IAEH;IACA;IAFd,YACc,QAAkC,EAClC,SAAkC,EAC5C,GAAG,IAA+C;QAElD,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;QAJL,aAAQ,GAAR,QAAQ,CAA0B;QAClC,cAAS,GAAT,SAAS,CAAyB;IAIhD,CAAC;IACM,MAAM;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACzB,CAAC;IACM,OAAO;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,OAAO,CAIvB,KAAuB,EACvB,OAA0B,EAC1B,IAA6C;QAE7C,IAAI,CAAC;YACD,OAAO,MAAM,IAAI,EAAE,CAAC;QACxB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,IAAI,CAAC,YAAY,WAAW,EAAE,CAAC,CAAA,CAAC;;gBAAM,MAAM,CAAC,CAAC;YAC9C,MAAM,WAAW,GAAG,CAA0B,CAAC;YAC/C,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC;YACvE,MAAM,CAAC,CAAC;QACZ,CAAC;IACL,CAAC;CACJ"}

package/build/engine/session.d.ts

@@ -1,38 +1,14 @@
 import { Function } from '../function.ts';
 import { Verbatim } from '../verbatim.ts';
-import { Media } from '../media.ts';
-declare const NOMINAL: unique symbol;
-export interface Session<userm, aim, devm> {
-    chatMessages: Session.ChatMessage<userm, aim>[];
-    developerMessage?: devm;
+import { RoleMessage } from './message.ts';
+export interface Session<in out fdu extends Function.Decl.Proto, in out vdu extends Verbatim.Decl.Proto> {
+    chatMessages: Session.ChatMessage<fdu, vdu>[];
+    developerMessage?: RoleMessage.Developer;
 }
 export declare namespace Session {
-    type ChatMessage<userm, aim> = userm | aim;
-}
-export declare namespace RoleMessage {
-    namespace Part {
-        class Text<out vdu extends Verbatim.Decl.Proto> {
-            text: string;
-            vrs: Verbatim.Request.Of<vdu>[];
-            static paragraph(text: string): Text<never>;
-            protected [NOMINAL]: never;
-            constructor(text: string, vrs: Verbatim.Request.Of<vdu>[]);
-        }
-    }
-    namespace Ai {
-        type Part<fdu extends Function.Decl.Proto, vdu extends Verbatim.Decl.Proto> = RoleMessage.Part.Text<vdu> | Function.Call.Of<fdu>;
-        namespace Part {
-            type From<fdm extends Function.Decl.Map.Proto, vdm extends Verbatim.Decl.Map.Proto> = RoleMessage.Ai.Part<Function.Decl.From<fdm>, Verbatim.Decl.From<vdm>>;
-        }
-    }
-    namespace User {
-        type Part<fdu extends Function.Decl.Proto> = RoleMessage.Part.Text<never> | Function.Response.Of<fdu> | Media;
-        namespace Part {
-            type From<fdm extends Function.Decl.Map.Proto> = RoleMessage.User.Part<Function.Decl.From<fdm>>;
-        }
-    }
-    namespace Developer {
-        type Part = RoleMessage.Part.Text<never>;
+    type From<fdm extends Function.Decl.Map.Proto, vdm extends Verbatim.Decl.Map.Proto> = Session<Function.Decl.From<fdm>, Verbatim.Decl.From<vdm>>;
+    type ChatMessage<fdu extends Function.Decl.Proto, vdu extends Verbatim.Decl.Proto> = RoleMessage.User<fdu> | RoleMessage.Ai<fdu, vdu>;
+    namespace ChatMessage {
+        type From<fdm extends Function.Decl.Map.Proto, vdm extends Verbatim.Decl.Map.Proto> = ChatMessage<Function.Decl.From<fdm>, Verbatim.Decl.From<vdm>>;
     }
 }
-export {};

package/build/engine/session.js

@@ -1,20 +1 @@
-const NOMINAL = Symbol();
-export var RoleMessage;
-(function (RoleMessage) {
-    let Part;
-    (function (Part) {
-        class Text {
-            text;
-            vrs;
-            static paragraph(text) {
-                return new RoleMessage.Part.Text(text.trimEnd() + '\n\n', []);
-            }
-            constructor(text, vrs) {
-                this.text = text;
-                this.vrs = vrs;
-            }
-        }
-        Part.Text = Text;
-    })(Part = RoleMessage.Part || (RoleMessage.Part = {}));
-})(RoleMessage || (RoleMessage = {}));
 //# sourceMappingURL=session.js.map

package/build/engine/session.js.map

@@ -1 +1 @@
-{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/engine/session.ts"],"names":[],"mappings":"AAIA,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC;AAazB,MAAM,KAAW,WAAW,CAqD3B;AArDD,WAAiB,WAAW;IAExB,IAAiB,IAAI,CAYpB;IAZD,WAAiB,IAAI;QACjB,MAAa,IAAI;YAOF;YACA;YAPJ,MAAM,CAAC,SAAS,CAAC,IAAY;gBAChC,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC,CAAC;YAClE,CAAC;YAGD,YACW,IAAY,EACZ,GAA+B;gBAD/B,SAAI,GAAJ,IAAI,CAAQ;gBACZ,QAAG,GAAH,GAAG,CAA4B;YACvC,CAAC;SACP;QAVY,SAAI,OAUhB,CAAA;IACL,CAAC,EAZgB,IAAI,GAAJ,gBAAI,KAAJ,gBAAI,QAYpB;AAuCL,CAAC,EArDgB,WAAW,KAAX,WAAW,QAqD3B"}
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/engine/session.ts"],"names":[],"mappings":""}

package/build/engine/structuring-validator.d.ts

@@ -0,0 +1,15 @@
+import { StructuringChoice } from '../structuring-choice.ts';
+import { Function } from '../function.ts';
+import { Verbatim } from '../verbatim.ts';
+import { RoleMessage } from './message.ts';
+export declare class StructuringValidator<in out fdu extends Function.Decl.Proto, in out vdu extends Verbatim.Decl.Proto> {
+    protected structuringChoice: StructuringChoice;
+    constructor(options: StructuringValidator.Options);
+    validate(aiMessage: RoleMessage.Ai<fdu, vdu>): RoleMessage.User<never> | void;
+}
+export declare namespace StructuringValidator {
+    type From<fdm extends Function.Decl.Map.Proto, vdm extends Verbatim.Decl.Map.Proto> = StructuringValidator<Function.Decl.From<fdm>, Verbatim.Decl.From<vdm>>;
+    interface Options {
+        structuringChoice: StructuringChoice;
+    }
+}

package/build/engine/structuring-validator.js

@@ -0,0 +1,64 @@
+import { StructuringChoice } from "../structuring-choice.js";
+import { RoleMessage } from "./message.js";
+import * as VerbatimCodec from "../verbatim/codec.js";
+export class StructuringValidator {
+    structuringChoice;
+    constructor(options) {
+        this.structuringChoice = options.structuringChoice;
+    }
+    validate(aiMessage) {
+        const fcalls = aiMessage.getFunctionCalls();
+        const vreqs = aiMessage.getVerbatimRequests();
+        if (this.structuringChoice === StructuringChoice.TCall.REQUIRED) {
+            if (!fcalls.length)
+                throw new SyntaxError('Function call required.');
+        }
+        else if (this.structuringChoice === StructuringChoice.TCall.ANYONE) {
+            if (!fcalls.length)
+                throw new SyntaxError('Function call required.');
+            if (fcalls.length > 1)
+                throw new SyntaxError('Only 1 function call allowed.');
+        }
+        else if (this.structuringChoice === StructuringChoice.VRequest.REQUIRED) {
+            if (!vreqs.length)
+                return new RoleMessage.User([
+                    RoleMessage.User.Part.Text.paragraph(VerbatimCodec.System.encode(`Error: Verbatim request required, but not found. Check your output format.`)),
+                ]);
+        }
+        else if (this.structuringChoice === StructuringChoice.VRequest.ANYONE) {
+            if (!vreqs.length)
+                return new RoleMessage.User([
+                    RoleMessage.User.Part.Text.paragraph(VerbatimCodec.System.encode(`Error: Verbatim request required, but not found. Check your output format.`)),
+                ]);
+            if (vreqs.length > 1)
+                return new RoleMessage.User([
+                    RoleMessage.User.Part.Text.paragraph(VerbatimCodec.System.encode(`Error: Only 1 verbatim request allowed, but multiple found.`)),
+                ]);
+        }
+        else if (this.structuringChoice === StructuringChoice.REQUIRED) {
+            if (fcalls.length + vreqs.length) { }
+            else
+                return new RoleMessage.User([
+                    RoleMessage.User.Part.Text.paragraph(VerbatimCodec.System.encode(`Error: Either function call or verbatim request required, but none found. Check your output format.`)),
+                ]);
+        }
+        else if (this.structuringChoice === StructuringChoice.ANYONE) {
+            if (fcalls.length + vreqs.length) { }
+            else
+                return new RoleMessage.User([
+                    RoleMessage.User.Part.Text.paragraph(VerbatimCodec.System.encode(`Error: Either 1 function call or 1 verbatim request required, but none found. Check your output format.`)),
+                ]);
+            if (fcalls.length + vreqs.length > 1)
+                return new RoleMessage.User([
+                    RoleMessage.User.Part.Text.paragraph(VerbatimCodec.System.encode(`Error: Either Only 1 function call or only 1 verbatim request allowed, but multiple found.`)),
+                ]);
+        }
+        else if (this.structuringChoice === StructuringChoice.NONE) {
+            if (fcalls.length + vreqs.length)
+                return new RoleMessage.User([
+                    RoleMessage.User.Part.Text.paragraph(VerbatimCodec.System.encode(`Error: Neither function call nor verbatim request allowed.`)),
+                ]);
+        }
+    }
+}
+//# sourceMappingURL=structuring-validator.js.map

package/build/engine/structuring-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"structuring-validator.js","sourceRoot":"","sources":["../../src/engine/structuring-validator.ts"],"names":[],"mappings":"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"}

package/build/engine/transport.d.ts

@@ -1,5 +1,8 @@
+import { Function } from '../function.ts';
 import { type InferenceContext } from '../inference-context.ts';
-import type { Session } from './session.ts';
-export interface Transport<userm, aim, devm, session extends Session<userm, aim, devm>> {
-    fetch(wfctx: InferenceContext, session: session, signal?: AbortSignal): Promise<aim>;
+import { Session } from './session.ts';
+import { RoleMessage } from './message.ts';
+import { Verbatim } from '../verbatim.ts';
+export interface Transport<in out fdm extends Function.Decl.Map.Proto, in out vdm extends Verbatim.Decl.Map.Proto> {
+    fetch(wfctx: InferenceContext, session: Session.From<fdm, vdm>, signal?: AbortSignal): Promise<RoleMessage.Ai.From<fdm, vdm>>;
 }

package/build/engine.d.ts

@@ -4,99 +4,100 @@ import { Throttle } from './throttle.ts';
 import { Dispatcher } from 'undici';
 import { type InferenceContext } from './inference-context.ts';
 import * as SessionModule from './engine/session.ts';
-import { Verbatim } from "./verbatim.js";
-import * as ValidationModule from './engine/validation.ts';
-import * as TransportModule from './engine/transport.ts';
+import * as MessageModule from './engine/message.ts';
+import { Verbatim } from './verbatim.ts';
+import { PartsValidator } from './engine/parts-validator.ts';
+import { Recoverable } from './engine/recoverable.ts';
+import { Middleware } from './engine/middleware.ts';
+import * as StructuringValidatorModule from './engine/structuring-validator.ts';
+import * as EngineTransportModule from './engine/transport.ts';
+import { StructuringChoice } from './structuring-choice.ts';
 export interface Pricing {
     inputPrice: number;
     cachePrice: number;
     outputPrice: number;
 }
-export interface ProviderSpec {
+export interface ProviderSpecs {
     baseUrl: string;
     apiKey: string;
     dispatcher: Dispatcher;
     retry: number;
 }
-export interface InferenceParams {
+export interface InferenceOptions {
     model: string;
     additionalOptions?: Record<string, unknown>;
     parallelToolCall?: boolean;
     timeout?: number;
     retry: number;
 }
-export type Engine<fdm extends Function.Decl.Map.Proto, vdm extends Verbatim.Decl.Map.Proto, userm, aim, devm, session extends Engine.Session<userm, aim, devm>> = Engine.Instance<fdm, vdm, userm, aim, devm, session>;
+export type Engine<fdm extends Function.Decl.Map.Proto, vdm extends Verbatim.Decl.Map.Proto> = Engine.Instance<fdm, vdm>;
 export declare namespace Engine {
-    abstract class Instance<in out fdm extends Function.Decl.Map.Proto, in out vdm extends Verbatim.Decl.Map.Proto, in out userm, in out aim, in out devm, in out session extends Engine.Session<userm, aim, devm>> {
-        protected providerSpec: ProviderSpec;
-        protected inferenceParams: InferenceParams;
+    abstract class Instance<in out fdm extends Function.Decl.Map.Proto, in out vdm extends Verbatim.Decl.Map.Proto> {
+        protected providerSpecs: ProviderSpecs;
+        protected inferenceOptions: InferenceOptions;
         name: string;
         pricing: Pricing;
         fdm: fdm;
         vdm: vdm;
         protected throttle: Throttle;
-        protected abstract structuringValidator: Engine.StructuringValidator<userm, aim>;
-        protected abstract partsValidator: Engine.PartsValidator<aim>;
-        protected abstract transport: Engine.Transport<userm, aim, devm, session>;
+        protected structuringChoice: StructuringChoice;
+        protected structuringValidator: Engine.StructuringValidator.From<fdm, vdm>;
+        protected partsValidator: PartsValidator.From<fdm, vdm>;
+        protected abstract transport: Engine.Transport<fdm, vdm>;
         constructor(options: Engine.Options<fdm, vdm>);
         /**
+        * @throws {@link InferenceTimeout} 推理超时
         * @throws {@link SyntaxError} 模型抽风
         * @throws {@link Recoverable} 模型抽风但可恢复
         * @throws {@link TypeError} 网络故障
         */
-        protected infer(wfctx: InferenceContext, session: session): Promise<aim>;
+        protected infer(wfctx: InferenceContext, session: Session.From<fdm, vdm>): Promise<RoleMessage.Ai.From<fdm, vdm>>;
         /**
         * @throws {@link InferenceTimeout} 推理超时
         * @throws {@link SyntaxError} 模型抽风
         * @throws {@link TypeError} 网络故障
         */
-        stateless(wfctx: InferenceContext, session: session): Promise<aim>;
+        stateless(wfctx: InferenceContext, session: Session.From<fdm, vdm>): Promise<RoleMessage.Ai.From<fdm, vdm>>;
         /**
         * @throws {@link InferenceTimeout} 推理超时
         * @throws {@link SyntaxError} 模型抽风
         * @throws {@link TypeError} 网络故障
         * @param session mutable
         */
-        stateful(wfctx: InferenceContext, session: session): Promise<aim>;
-        abstract appendUserMessage(session: session, message: userm): session;
+        stateful(wfctx: InferenceContext, session: Session.From<fdm, vdm>): Promise<RoleMessage.Ai.From<fdm, vdm>>;
+        abstract clone(): Engine<fdm, vdm>;
+        protected middlewaresStateless: Middleware.From<fdm, vdm>[];
+        useStateless(middleware: Middleware.From<fdm, vdm>): Engine<fdm, vdm>;
+        protected middlewaresStateful: Middleware.From<fdm, vdm>[];
+        useStateful(middleware: Middleware.From<fdm, vdm>): Engine<fdm, vdm>;
+        protected compose(middlewares: Middleware.From<fdm, vdm>[]): Middleware.From<fdm, vdm>;
         /**
-        * @param session mutable
-        */
-        abstract pushUserMessage(session: session, message: userm): session;
-        abstract clone(): Engine<fdm, vdm, userm, aim, devm, session>;
-        protected middlewares: Middleware<userm, aim, devm, session>[];
-        use(middleware: Middleware<userm, aim, devm, session>): Engine<fdm, vdm, userm, aim, devm, session>;
-        protected statefulMiddlewares: Middleware<userm, aim, devm, session>[];
-        statefulUse(middleware: Middleware<userm, aim, devm, session>): ReturnType<typeof this['clone']>;
-        protected compose(middlewares: Middleware<userm, aim, devm, session>[], i?: number): Middleware<userm, aim, devm, session>;
+         * @param session mutable
+         */
+        agentloop(wfctx: InferenceContext, session: Session.From<fdm, vdm>, fnm: Function.Map<fdm>, vhm: Verbatim.Handler.Map<vdm>, limit?: number): AsyncGenerator<string, string, void>;
     }
-    interface Middleware<userm, aim, devm, session extends Engine.Session<userm, aim, devm>> {
-        (wfctx: InferenceContext, session: session, next: () => Promise<aim>): Promise<aim>;
+    class FunctionCallLimitExceeded extends Error {
     }
     interface Options<in out fdm extends Function.Decl.Map.Proto, in out vdm extends Verbatim.Decl.Map.Proto> {
         throttle: Throttle;
         endpointSpec: EndpointSpec;
         functionDeclarationMap: fdm;
         verbatimDeclarationMap: vdm;
+        structuringChoice?: StructuringChoice;
         providerRetry?: number;
         inferenceRetry?: number;
     }
+    interface Create {
+        <fdm extends Function.Decl.Map.Proto, vdm extends Verbatim.Decl.Map.Proto>(options: Engine.Options<fdm, vdm>): Engine<fdm, vdm>;
+    }
+    export import Transport = EngineTransportModule.Transport;
+    export import StructuringValidator = StructuringValidatorModule.StructuringValidator;
     export import Session = SessionModule.Session;
-    export import RoleMessage = SessionModule.RoleMessage;
-    export import StructuringValidator = ValidationModule.StructuringValidator;
-    export import PartsValidator = ValidationModule.PartsValidator;
-    export import Transport = TransportModule.Transport;
+    export import RoleMessage = MessageModule.RoleMessage;
 }
 export declare class InferenceTimeout extends Error {
 }
-export declare class Recoverable<userm, aim> extends SyntaxError {
-    protected response: aim;
-    protected rejection: userm;
-    constructor(response: aim, rejection: userm, ...rest: ConstructorParameters<typeof SyntaxError>);
-    resume(): aim;
-    recover(): userm;
-    static recover<userm, aim, devm, session extends Engine.Session<userm, aim, devm>>(wfctx: InferenceContext, session: session, next: () => Promise<aim>): Promise<aim>;
-}
+export { Recoverable, Middleware };
 declare global {
     export namespace NodeJS {
         interface ProcessEnv {

package/build/engine.js

@@ -1,17 +1,25 @@
+import { Function } from "./function.js";
 import { Agent, ProxyAgent } from 'undici';
 import { env } from 'node:process';
 import { loggers } from "./telemetry.js";
-import * as SessionModule from "./engine/session.js";
+import * as MessageModule from "./engine/message.js";
+import { PartsValidator } from "./engine/parts-validator.js";
+import { Recoverable } from "./engine/recoverable.js";
+import * as StructuringValidatorModule from "./engine/structuring-validator.js";
+import { StructuringChoice } from "./structuring-choice.js";
 export var Engine;
 (function (Engine) {
     class Instance {
-        providerSpec;
-        inferenceParams;
+        providerSpecs;
+        inferenceOptions;
         name;
         pricing;
         fdm;
         vdm;
         throttle;
+        structuringChoice;
+        structuringValidator;
+        partsValidator;
         constructor(options) {
             const proxyUrl = options.endpointSpec.proxy || env.https_proxy || env.HTTPS_PROXY;
             const dispatcher = proxyUrl
@@ -24,14 +32,14 @@ export var Engine;
                     headersTimeout: 10000,
                     bodyTimeout: 0,
                 });
-            this.providerSpec = {
+            this.providerSpecs = {
                 baseUrl: options.endpointSpec.baseUrl,
                 apiKey: options.endpointSpec.apiKey,
                 dispatcher,
                 retry: options.providerRetry ?? 2,
             };
             this.name = options.endpointSpec.name;
-            this.inferenceParams = {
+            this.inferenceOptions = {
                 model: options.endpointSpec.model,
                 additionalOptions: options.endpointSpec.additionalOptions,
                 timeout: options.endpointSpec.timeout,
@@ -45,15 +53,19 @@ export var Engine;
             };
             this.fdm = options.functionDeclarationMap;
             this.vdm = options.verbatimDeclarationMap;
+            this.structuringChoice = options.structuringChoice ?? StructuringChoice.AUTO;
             this.throttle = options.throttle;
+            this.partsValidator = new PartsValidator();
+            this.structuringValidator = new Engine.StructuringValidator({ structuringChoice: this.structuringChoice });
         }
         /**
+        * @throws {@link InferenceTimeout} 推理超时
         * @throws {@link SyntaxError} 模型抽风
         * @throws {@link Recoverable} 模型抽风但可恢复
         * @throws {@link TypeError} 网络故障
         */
         async infer(wfctx, session) {
-            const signalTimeout = this.inferenceParams.timeout ? AbortSignal.timeout(this.inferenceParams.timeout) : null;
+            const signalTimeout = this.inferenceOptions.timeout ? AbortSignal.timeout(this.inferenceOptions.timeout) : null;
             const signals = [];
             if (signalTimeout)
                 signals.push(signalTimeout);
@@ -81,29 +93,28 @@ export var Engine;
         * @throws {@link TypeError} 网络故障
         */
         async stateless(wfctx, session) {
-            const middleware = this.compose(this.middlewares);
+            const middleware = this.compose(this.middlewaresStateless);
             for (let retryProvider = 0, retryInference = 0;;)
                 try {
-                    const next = () => this.infer(wfctx, session);
-                    return await middleware(wfctx, session, next);
+                    return await middleware(wfctx, session, () => this.infer(wfctx, session));
                 }
                 catch (e) {
                     if (e instanceof InferenceTimeout) { // 推理超时
-                        if (retryInference < this.inferenceParams.retry) { }
+                        if (retryInference < this.inferenceOptions.retry) { }
                         else
                             throw e;
                         loggers.message.warn(e);
                         retryInference++;
                     }
                     else if (e instanceof SyntaxError) { // 模型抽风
-                        if (retryInference < this.inferenceParams.retry) { }
+                        if (retryInference < this.inferenceOptions.retry) { }
                         else
                             throw e;
                         loggers.message.warn(e);
                         retryInference++;
                     }
                     else if (e instanceof TypeError) { // 网络故障
-                        if (retryProvider < this.providerSpec.retry) { }
+                        if (retryProvider < this.providerSpecs.retry) { }
                         else
                             throw e;
                         loggers.message.warn(e);
@@ -120,35 +131,33 @@ export var Engine;
         * @param session mutable
         */
         async stateful(wfctx, session) {
-            const middleware = this.compose(this.middlewares);
-            const statefulMiddleware = this.compose(this.statefulMiddlewares);
+            const middleware = this.compose(this.middlewaresStateful);
             for (let retryProvider = 0, retryInference = 0;;)
                 try {
-                    const next = () => this.infer(wfctx, session);
-                    const statefulNext = async () => {
-                        const aiMessage = await middleware(wfctx, session, next);
+                    const next = async () => {
+                        const aiMessage = await this.infer(wfctx, session);
                         session.chatMessages.push(aiMessage);
                         return aiMessage;
                     };
-                    return await statefulMiddleware(wfctx, session, statefulNext);
+                    return await middleware(wfctx, session, next);
                 }
                 catch (e) {
                     if (e instanceof InferenceTimeout) { // 推理超时
-                        if (retryInference < this.inferenceParams.retry) { }
+                        if (retryInference < this.inferenceOptions.retry) { }
                         else
                             throw e;
                         loggers.message.warn(e);
                         retryInference++;
                     }
                     else if (e instanceof SyntaxError) { // 模型抽风
-                        if (retryInference < this.inferenceParams.retry) { }
+                        if (retryInference < this.inferenceOptions.retry) { }
                         else
                             throw e;
                         loggers.message.warn(e);
                         retryInference++;
                     }
                     else if (e instanceof TypeError) { // 网络故障
-                        if (retryProvider < this.providerSpec.retry) { }
+                        if (retryProvider < this.providerSpecs.retry) { }
                         else
                             throw e;
                         loggers.message.warn(e);
@@ -158,59 +167,86 @@ export var Engine;
                         throw e;
                 }
         }
-        middlewares = [];
-        use(middleware) {
+        middlewaresStateless = [];
+        useStateless(middleware) {
             const engine = this.clone();
-            engine.middlewares.push(middleware);
+            engine.middlewaresStateless.push(middleware);
             return engine;
         }
-        statefulMiddlewares = [];
-        statefulUse(middleware) {
+        middlewaresStateful = [];
+        useStateful(middleware) {
             const engine = this.clone();
-            engine.statefulMiddlewares.push(middleware);
+            engine.middlewaresStateful.push(middleware);
             return engine;
         }
-        compose(middlewares, i = 0) {
-            if (i < middlewares.length)
-                return async (wfctx, session, next) => {
-                    const middleware = middlewares[i];
-                    const nextMiddlewares = this.compose(middlewares, i + 1);
-                    return middleware(wfctx, session, () => nextMiddlewares(wfctx, session, next));
-                };
-            else
-                return (wfctx, session, next) => next();
+        compose(middlewares) {
+            let composed = (wfctx, session, next) => next();
+            for (const middleware of middlewares.slice().reverse()) {
+                const nextMiddleware = composed;
+                composed = (wfctx, session, next) => middleware(wfctx, session, () => nextMiddleware(wfctx, session, next));
+            }
+            return composed;
+        }
+        /**
+         * @param session mutable
+         */
+        async *agentloop(wfctx, session, fnm, vhm, limit = Number.POSITIVE_INFINITY) {
+            for (let i = 0; i < limit; i++) {
+                const response = await this.stateful(wfctx, session);
+                if (response.allChat())
+                    return response.getChat();
+                const pfress = [];
+                const pvress = [];
+                for (const part of response.getParts()) {
+                    if (part instanceof Engine.RoleMessage.Ai.Part.Text) {
+                        const textPart = part;
+                        yield textPart.text;
+                        for (const vreq of textPart.vreqs) {
+                            const vh = vhm[vreq.name];
+                            pvress.push((async () => new Engine.RoleMessage.User.Part.Text(await vh.call(vhm, vreq.args)))());
+                        }
+                    }
+                    else if (part instanceof Function.Call) {
+                        const fcall = part;
+                        const f = fnm[fcall.name];
+                        pfress.push((async () => {
+                            try {
+                                return Function.Response.Successful.of({
+                                    id: fcall.id,
+                                    name: fcall.name,
+                                    text: await f.call(fnm, fcall.args),
+                                });
+                            }
+                            catch (e) {
+                                if (e instanceof Function.Error) { }
+                                else
+                                    throw e;
+                                return Function.Response.Failed.of({
+                                    id: fcall.id,
+                                    name: fcall.name,
+                                    error: e.message,
+                                });
+                            }
+                        })());
+                    }
+                    else
+                        throw new Error();
+                }
+                const fress = await Promise.all(pfress);
+                const vress = await Promise.all(pvress);
+                session.chatMessages.push(new Engine.RoleMessage.User([...fress, ...vress]));
+            }
+            throw new Engine.FunctionCallLimitExceeded('Function call limit exceeded.');
         }
     }
     Engine.Instance = Instance;
-    Engine.RoleMessage = SessionModule.RoleMessage;
+    class FunctionCallLimitExceeded extends Error {
+    }
+    Engine.FunctionCallLimitExceeded = FunctionCallLimitExceeded;
+    Engine.StructuringValidator = StructuringValidatorModule.StructuringValidator;
+    Engine.RoleMessage = MessageModule.RoleMessage;
 })(Engine || (Engine = {}));
 export class InferenceTimeout extends Error {
 }
-export class Recoverable extends SyntaxError {
-    response;
-    rejection;
-    constructor(response, rejection, ...rest) {
-        super(...rest);
-        this.response = response;
-        this.rejection = rejection;
-    }
-    resume() {
-        return this.response;
-    }
-    recover() {
-        return this.rejection;
-    }
-    static async recover(wfctx, session, next) {
-        try {
-            return await next();
-        }
-        catch (e) {
-            if (e instanceof Recoverable) { }
-            else
-                throw e;
-            session.chatMessages.push(e.resume(), e.recover());
-            throw e;
-        }
-    }
-}
+export { Recoverable };
 //# sourceMappingURL=engine.js.map