@aigne/core 1.34.0 → 1.37.0

package/CHANGELOG.md

@@ -12,6 +12,32 @@
   * dependencies
     * @aigne/observability bumped to 0.1.0
 
+## [1.37.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.36.0...core-v1.37.0) (2025-07-22)
+
+
+### Features
+
+* **core:** add reflection mode support to TeamAgent ([#273](https://github.com/AIGNE-io/aigne-framework/issues/273)) ([4e2dad6](https://github.com/AIGNE-io/aigne-framework/commit/4e2dad687c1caefa231c7a7620651d060f8c8b9d))
+
+
+### Bug Fixes
+
+* **core:** function agent should use common schema from yaml definition ([#270](https://github.com/AIGNE-io/aigne-framework/issues/270)) ([076a489](https://github.com/AIGNE-io/aigne-framework/commit/076a4896948c397518e99df46c1a443ea43daa64))
+
+## [1.36.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.35.0...core-v1.36.0) (2025-07-17)
+
+
+### Features
+
+* **core:** support define hooks for agent in yaml ([#260](https://github.com/AIGNE-io/aigne-framework/issues/260)) ([c388e82](https://github.com/AIGNE-io/aigne-framework/commit/c388e8216134271af4d9c7def70862ea3c354c7f))
+
+## [1.35.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.34.0...core-v1.35.0) (2025-07-17)
+
+
+### Features
+
+* **core:** support custom default input value for agent ([#258](https://github.com/AIGNE-io/aigne-framework/issues/258)) ([352ac70](https://github.com/AIGNE-io/aigne-framework/commit/352ac70400fb7e28cc36c4f6dc9c591b0d64e546))
+
 ## [1.34.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.33.2...core-v1.34.0) (2025-07-15)
 
 

package/lib/cjs/agents/agent.d.ts

@@ -10,6 +10,7 @@ import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils
 import type { GuideRailAgent, GuideRailAgentOutput } from "./guide-rail-agent.js";
 import { type TransferAgentOutput } from "./types.js";
 export * from "./types.js";
+export declare const DEFAULT_INPUT_ACTION_GET = "$get";
 /**
  * Basic message type that can contain any key-value pairs
  */
@@ -72,6 +73,11 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * Used to validate that input messages conform to the expected format
      */
     inputSchema?: AgentInputOutputSchema<I>;
+    /**
+     * Default input message for the agent, it can be used to provide partial input
+     * or default values for the agent's input schema.
+     */
+    defaultInput?: Agent<I, O>["defaultInput"];
     /**
      * Zod schema defining the output message structure
      *
@@ -106,7 +112,7 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * Maximum number of memory items to retrieve
      */
     maxRetrieveMemoryCount?: number;
-    hooks?: AgentHooks<I, O>;
+    hooks?: AgentHooks<I, O> | AgentHooks<I, O>[];
 }
 export declare const agentOptionsSchema: ZodObject<{
     [key in keyof AgentOptions]: ZodType<AgentOptions[key]>;
@@ -137,6 +143,10 @@ export interface AgentInvokeOptions<U extends UserContext = UserContext> {
      * and returns the final JSON result
      */
     streaming?: boolean;
+    /**
+     * Optional hooks for agent invocation
+     */
+    hooks?: AgentHooks<any, any>;
 }
 /**
  * Agent is the base class for all agents.
@@ -190,7 +200,7 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * Here's an example of using hooks:
      * {@includeCode ../../test/agents/agent.test.ts#example-agent-hooks}
      */
-    readonly hooks: AgentHooks<I, O>;
+    readonly hooks: AgentHooks<I, O>[];
     /**
      * List of GuideRail agents applied to this agent
      *
@@ -232,6 +242,11 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      */
     readonly description?: string;
     private readonly _inputSchema?;
+    defaultInput?: Partial<{
+        [key in keyof I]: {
+            [DEFAULT_INPUT_ACTION_GET]: string;
+        } | I[key];
+    }>;
     private readonly _outputSchema?;
     /**
      * Get the input data schema for this agent
@@ -372,6 +387,8 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @returns Agent response (streaming or regular)
      */
     invoke(input: I & Message, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    private callHooks;
+    private mergeDefaultInput;
     protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I & Message, options: AgentInvokeOptions): Promise<O>;
     /**
      * Process agent output
@@ -517,11 +534,15 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the input message
      */
-    onStart?: (event: {
+    onStart?: ((event: {
         context: Context;
         input: I;
     }) => PromiseOrValue<void | {
         input?: I;
+    }>) | Agent<{
+        input: I;
+    }, {
+        input?: I;
     }>;
     /**
      * Called when agent processing completes or fails
@@ -532,13 +553,39 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the input message and either output or error
      */
-    onEnd?: (event: XOr<{
+    onEnd?: ((event: XOr<{
         context: Context;
         input: I;
         output: O;
         error: Error;
     }, "output", "error">) => PromiseOrValue<void | {
         output?: O;
+    }>) | Agent<XOr<{
+        input: I;
+        output: O;
+        error: Error;
+    }, "output", "error">, {
+        output?: O;
+    }>;
+    onSuccess?: ((event: {
+        context: Context;
+        input: I;
+        output: O;
+    }) => PromiseOrValue<void | {
+        output?: O;
+    }>) | Agent<{
+        input: I;
+        output: O;
+    }, {
+        output?: O;
+    }>;
+    onError?: ((event: {
+        context: Context;
+        input: I;
+        error: Error;
+    }) => void) | Agent<{
+        input: I;
+        error: Error;
     }>;
     /**
      * Called before a skill (sub-agent) is invoked
@@ -548,11 +595,14 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the skill being used and input message
      */
-    onSkillStart?: (event: {
+    onSkillStart?: ((event: {
         context: Context;
         skill: Agent;
         input: Message;
-    }) => PromiseOrValue<void>;
+    }) => PromiseOrValue<void>) | Agent<{
+        skill: Agent;
+        input: Message;
+    }>;
     /**
      * Called after a skill (sub-agent) completes or fails
      *
@@ -562,13 +612,18 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the skill used, input message, and either output or error
      */
-    onSkillEnd?: (event: XOr<{
+    onSkillEnd?: ((event: XOr<{
         context: Context;
         skill: Agent;
         input: Message;
         output: Message;
         error: Error;
-    }, "output", "error">) => PromiseOrValue<void>;
+    }, "output", "error">) => PromiseOrValue<void>) | Agent<XOr<{
+        skill: Agent;
+        input: Message;
+        output: Message;
+        error: Error;
+    }, "output", "error">>;
     /**
      * Called when an agent hands off processing to another agent
      *
@@ -578,13 +633,19 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the source agent, target agent, and input message
      */
-    onHandoff?: (event: {
+    onHandoff?: ((event: {
         context: Context;
         source: Agent;
         target: Agent;
         input: I;
-    }) => PromiseOrValue<void>;
+    }) => PromiseOrValue<void>) | Agent<{
+        source: Agent;
+        target: Agent;
+        input: I;
+    }>;
 }
+export type AgentHookInput<H extends keyof AgentHooks, Hook extends AgentHooks[H] = AgentHooks[H]> = Hook extends (input: infer I) => any ? Omit<I, "context"> : never;
+export type AgentHookOutput<H extends keyof AgentHooks, Hook extends AgentHooks[H] = AgentHooks[H]> = Hook extends (...args: any[]) => any ? Exclude<Awaited<ReturnType<Hook>>, void> | undefined : never;
 /**
  * Response type for an agent, can be:
  * - Direct response object

package/lib/cjs/agents/agent.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionAgent = exports.Agent = exports.agentOptionsSchema = void 0;
+exports.FunctionAgent = exports.Agent = exports.agentOptionsSchema = exports.DEFAULT_INPUT_ACTION_GET = void 0;
 exports.isEmptyChunk = isEmptyChunk;
 exports.isAgentResponseDelta = isAgentResponseDelta;
 exports.isAgentResponseProgress = isAgentResponseProgress;
@@ -50,6 +50,14 @@ const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const types_js_1 = require("./types.js");
 __exportStar(require("./types.js"), exports);
+exports.DEFAULT_INPUT_ACTION_GET = "$get";
+const hooksSchema = zod_1.z.object({
+    onStart: zod_1.z.custom().optional(),
+    onEnd: zod_1.z.custom().optional(),
+    onSkillStart: zod_1.z.custom().optional(),
+    onSkillEnd: zod_1.z.custom().optional(),
+    onHandoff: zod_1.z.custom().optional(),
+});
 exports.agentOptionsSchema = zod_1.z.object({
     subscribeTopic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
     publishTopic: zod_1.z
@@ -58,21 +66,14 @@ exports.agentOptionsSchema = zod_1.z.object({
     name: zod_1.z.string().optional(),
     description: zod_1.z.string().optional(),
     inputSchema: zod_1.z.custom().optional(),
+    defaultInput: zod_1.z.record(zod_1.z.any()).optional(),
     outputSchema: zod_1.z.custom().optional(),
     includeInputInOutput: zod_1.z.boolean().optional(),
     skills: zod_1.z.array(zod_1.z.union([zod_1.z.custom(), zod_1.z.custom()])).optional(),
     disableEvents: zod_1.z.boolean().optional(),
     memory: zod_1.z.union([zod_1.z.custom(), zod_1.z.array(zod_1.z.custom())]).optional(),
     maxRetrieveMemoryCount: zod_1.z.number().optional(),
-    hooks: zod_1.z
-        .object({
-        onStart: zod_1.z.custom().optional(),
-        onEnd: zod_1.z.custom().optional(),
-        onSkillStart: zod_1.z.custom().optional(),
-        onSkillEnd: zod_1.z.custom().optional(),
-        onHandoff: zod_1.z.custom().optional(),
-    })
-        .optional(),
+    hooks: zod_1.z.union([zod_1.z.array(hooksSchema), hooksSchema]).optional(),
     guideRails: zod_1.z.array(zod_1.z.custom()).optional(),
 });
 /**
@@ -107,6 +108,7 @@ class Agent {
         if (outputSchema)
             checkAgentInputOutputSchema(outputSchema);
         this._inputSchema = inputSchema;
+        this.defaultInput = options.defaultInput;
         this._outputSchema = outputSchema;
         this.includeInputInOutput = options.includeInputInOutput;
         this.subscribeTopic = options.subscribeTopic;
@@ -121,7 +123,7 @@ class Agent {
             this.memories.push(options.memory);
         }
         this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
-        this.hooks = options.hooks ?? {};
+        this.hooks = (0, type_utils_js_1.flat)(options.hooks);
         this.guideRails = options.guideRails;
     }
     /**
@@ -187,6 +189,7 @@ class Agent {
      */
     description;
     _inputSchema;
+    defaultInput;
     _outputSchema;
     /**
      * Get the input data schema for this agent
@@ -336,17 +339,23 @@ class Agent {
             ...options,
             context: options.context ?? (await this.newDefaultContext()),
         };
+        input = this.mergeDefaultInput(input);
         logger_js_1.logger.debug("Invoke agent %s started with input: %O", this.name, input);
         if (!this.disableEvents)
             opts.context.emit("agentStarted", { agent: this, input });
         try {
-            let parsedInput = (await this.hooks.onStart?.({ context: opts.context, input }))?.input ?? input;
-            parsedInput = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} input`, this.inputSchema, input);
-            await this.preprocess(parsedInput, opts);
+            let response;
+            const s = await this.callHooks("onStart", { input }, opts);
+            if (s?.input)
+                input = s.input;
+            input = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} input`, this.inputSchema, input);
+            await this.preprocess(input, opts);
             this.checkContextStatus(opts);
-            let response = await this.process(parsedInput, opts);
-            if (response instanceof Agent) {
-                response = (0, types_js_1.transferToAgentOutput)(response);
+            if (!response) {
+                response = await this.process(input, opts);
+                if (response instanceof Agent) {
+                    response = (0, types_js_1.transferToAgentOutput)(response);
+                }
             }
             if (opts.streaming) {
                 const stream = response instanceof ReadableStream
@@ -356,29 +365,62 @@ class Agent {
                         : (0, stream_utils_js_1.objectToAgentResponseStream)(response);
                 return this.checkResponseByGuideRails(input, (0, stream_utils_js_1.onAgentResponseStreamEnd)(stream, {
                     onResult: async (result) => {
-                        return await this.processAgentOutput(parsedInput, result, opts);
+                        return await this.processAgentOutput(input, result, opts);
                     },
                     onError: async (error) => {
                         return await this.processAgentError(input, error, opts);
                     },
                 }), opts);
             }
-            return await this.checkResponseByGuideRails(input, this.processAgentOutput(parsedInput, await agentProcessResultToObject(response), opts), opts);
+            return await this.checkResponseByGuideRails(input, this.processAgentOutput(input, await agentProcessResultToObject(response), opts), opts);
         }
         catch (error) {
             throw await this.processAgentError(input, error, opts);
         }
     }
+    async callHooks(hook, input, options) {
+        const { context } = options;
+        const result = {};
+        for (const hooks of (0, type_utils_js_1.flat)(options.hooks, this.hooks)) {
+            const h = hooks[hook];
+            if (!h)
+                continue;
+            if (typeof h === "function") {
+                Object.assign(result, await h({ ...input, context }));
+            }
+            else {
+                Object.assign(result, await context.invoke(h, input));
+            }
+        }
+        return result;
+    }
+    mergeDefaultInput(input) {
+        const defaultInput = Object.fromEntries(Object.entries(this.defaultInput ?? {}).filter(([, v]) => !(typeof v === "object" && exports.DEFAULT_INPUT_ACTION_GET in v)));
+        input = { ...defaultInput, ...input };
+        for (const key of Object.keys(this.defaultInput ?? {})) {
+            const v = this.defaultInput?.[key];
+            if (v &&
+                typeof v === "object" &&
+                exports.DEFAULT_INPUT_ACTION_GET in v &&
+                typeof v[exports.DEFAULT_INPUT_ACTION_GET] === "string" &&
+                (0, type_utils_js_1.isNil)(input[key])) {
+                const value = input[v[exports.DEFAULT_INPUT_ACTION_GET]];
+                if (!(0, type_utils_js_1.isNil)(value))
+                    Object.assign(input, { [key]: value });
+            }
+        }
+        return input;
+    }
     async invokeSkill(skill, input, options) {
         const { context } = options;
-        await this.hooks.onSkillStart?.({ context, skill, input });
+        await this.callHooks("onSkillStart", { skill, input }, options);
         try {
             const output = await context.invoke(skill, input);
-            await this.hooks.onSkillEnd?.({ context, skill, input, output });
+            await this.callHooks("onSkillEnd", { skill, input, output }, options);
             return output;
         }
         catch (error) {
-            await this.hooks.onSkillEnd?.({ context, skill, input, error });
+            await this.callHooks("onSkillEnd", { skill, input, error }, options);
             throw error;
         }
     }
@@ -398,14 +440,17 @@ class Agent {
             throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof output}): ${output}`);
         }
         const parsedOutput = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} output`, this.outputSchema, output);
-        const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
+        let finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
         await this.postprocess(input, finalOutput, options);
         logger_js_1.logger.debug("Invoke agent %s succeed with output: %O", this.name, finalOutput);
         if (!this.disableEvents)
             context.emit("agentSucceed", { agent: this, output: finalOutput });
-        const o = (await this.hooks.onEnd?.({ context, input, output: finalOutput }))?.output;
-        if (o)
-            return o;
+        let o = await this.callHooks("onSuccess", { input, output: finalOutput }, options);
+        if (o?.output)
+            finalOutput = o.output;
+        o = await this.callHooks("onEnd", { input, output: finalOutput }, options);
+        if (o?.output)
+            finalOutput = o.output;
         return finalOutput;
     }
     /**
@@ -420,8 +465,8 @@ class Agent {
         logger_js_1.logger.error("Invoke agent %s failed with error: %O", this.name, error);
         if (!this.disableEvents)
             options.context.emit("agentFailed", { agent: this, error });
-        const { context } = options;
-        await this.hooks.onEnd?.({ context, input, error });
+        await this.callHooks("onError", { input, error }, options);
+        await this.callHooks("onEnd", { input, error }, options);
         return error;
     }
     /**

package/lib/cjs/agents/ai-agent.js

@@ -243,7 +243,7 @@ class AIAgent extends agent_js_1.Agent {
         const outputKey = this.outputKey;
         for (;;) {
             const modelOutput = {};
-            let stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            let stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { ...options, streaming: true });
             if (this.structuredStreamMode) {
                 const { metadataStart, metadataEnd, parse } = this.customStructuredStreamInstructions || structured_stream_instructions_js_1.STRUCTURED_STREAM_INSTRUCTIONS;
                 stream = stream.pipeThrough(new structured_stream_extractor_js_1.ExtractMetadataTransform({ start: metadataStart, end: metadataEnd, parse }));
@@ -318,14 +318,17 @@ class AIAgent extends agent_js_1.Agent {
      * @protected
      */
     async *_processRouter(input, model, modelInput, options, toolsMap) {
-        const { toolCalls: [call] = [] } = await options.context.invoke(model, modelInput);
+        const { toolCalls: [call] = [] } = await options.context.invoke(model, modelInput, {
+            ...options,
+            streaming: false,
+        });
         if (!call) {
             throw new Error("Router toolChoice requires exactly one tool to be executed");
         }
         const tool = toolsMap.get(call.function.name);
         if (!tool)
             throw new Error(`Tool not found: ${call.function.name}`);
-        const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true, sourceAgent: this });
+        const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { ...options, streaming: true, sourceAgent: this });
         return yield* stream;
     }
 }

package/lib/cjs/agents/team-agent.d.ts

@@ -22,6 +22,73 @@ export declare enum ProcessMode {
      */
     parallel = "parallel"
 }
+export declare const DEFAULT_REFLECTION_MAX_ITERATIONS = 3;
+/**
+ * Configuration for reflection mode processing in TeamAgent.
+ *
+ * Reflection mode enables iterative refinement of agent outputs through a review process.
+ * The team agent will repeatedly process the input and have a reviewer agent evaluate
+ * the output until it meets approval criteria or reaches the maximum iteration limit.
+ *
+ * This is particularly useful for:
+ * - Quality assurance workflows where outputs need validation
+ * - Iterative improvement processes where initial results can be refined
+ * - Self-correcting agent systems that learn from feedback
+ */
+export interface ReflectionMode {
+    /**
+     * The agent responsible for reviewing and providing feedback on the team's output.
+     *
+     * The reviewer agent receives the combined output from the team's processing
+     * and should provide feedback or evaluation that can be used to determine
+     * whether the output meets the required standards.
+     */
+    reviewer: Agent;
+    /**
+     * Function that determines whether the reviewer's output indicates approval.
+     *
+     * This function receives the reviewer agent's output message and should return:
+     * - `true` or truthy value: The output is approved and processing should stop
+     * - `false` or falsy value: The output needs improvement and another iteration should run
+     *
+     * The function can be synchronous or asynchronous, allowing for complex approval logic
+     * including external validation, scoring systems, or human-in-the-loop approval.
+     *
+     * @param output - The message output from the reviewer agent
+     * @returns A boolean or truthy/falsy value indicating approval status
+     */
+    isApproved: (output: Message) => PromiseOrValue<boolean | unknown>;
+    /**
+     * Maximum number of reflection iterations before giving up.
+     *
+     * This prevents infinite loops when the approval criteria cannot be met.
+     * If the maximum iterations are reached without approval, the process will
+     * throw an error indicating the reflection failed to converge.
+     *
+     * @default 3
+     */
+    maxIterations?: number;
+    /**
+     * Controls the behavior when maximum iterations are reached without approval.
+     *
+     * When set to `true`, the TeamAgent will return the last generated output
+     * instead of throwing an error when the maximum number of reflection iterations
+     * is reached without the reviewer's approval.
+     *
+     * When set to `false` or undefined, the TeamAgent will throw an error
+     * indicating that the reflection process failed to converge within the
+     * maximum iteration limit.
+     *
+     * This option is useful for scenarios where:
+     * - You want to get the best available result even if it's not perfect
+     * - The approval criteria might be too strict for the given context
+     * - You prefer graceful degradation over complete failure
+     * - You want to implement custom error handling based on the returned result
+     *
+     * @default false
+     */
+    returnLastOnMaxIterations?: boolean;
+}
 /**
  * Configuration options for creating a TeamAgent.
  *
@@ -33,6 +100,21 @@ export interface TeamAgentOptions<I extends Message, O extends Message> extends
      * @default {ProcessMode.sequential}
      */
     mode?: ProcessMode;
+    /**
+     * Configuration for reflection mode processing.
+     *
+     * When enabled, the TeamAgent will use an iterative refinement process where:
+     * 1. The team processes the input normally
+     * 2. A reviewer agent evaluates the output
+     * 3. If not approved, the process repeats with the previous output as context
+     * 4. This continues until approval or maximum iterations are reached
+     *
+     * This enables self-improving agent workflows that can iteratively refine
+     * their outputs based on feedback from a specialized reviewer agent.
+     *
+     * @see ReflectionMode for detailed configuration options
+     */
+    reflection?: ReflectionMode;
     /**
      * Specifies which input field should be treated as an array for iterative processing.
      *
@@ -116,6 +198,14 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      * This can be either sequential (one after another) or parallel (all at once).
      */
     mode: ProcessMode;
+    /**
+     * The reflection mode configuration with guaranteed maxIterations value.
+     *
+     * This is the internal representation after processing the user-provided
+     * reflection configuration, ensuring that maxIterations always has a value
+     * (defaulting to DEFAULT_REFLECTION_MAX_ITERATIONS if not specified).
+     */
+    reflection?: ReflectionMode & Required<Pick<ReflectionMode, "maxIterations">>;
     /**
      * The input field key to iterate over when processing array inputs.
      *
@@ -148,8 +238,10 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      * @returns A stream of message chunks that collectively form the response
      */
     process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    private _processNonReflection;
+    private _processReflection;
     private _processIterator;
-    private _process;
+    private _processNonIterator;
     /**
      * Process input sequentially through each agent in the team.
      *