knockagent 0.1.0

package/dist/KnockAgent.js

@@ -0,0 +1,219 @@
+import Loader from "./Loader.js";
+import { Agent, Runner, setTracingDisabled } from "@openai/agents";
+import { promptWithHandoffInstructions } from "@openai/agents-core/extensions";
+import { Liquid } from "liquidjs";
+function parseTemprature(t) {
+    if (typeof t === "number")
+        return t;
+    if (typeof t === "string") {
+        const n = Number.parseFloat(t);
+        return Number.isNaN(n) ? null : n;
+    }
+    return null;
+}
+function split(list) {
+    if (Array.isArray(list))
+        return list.map(item => String(item));
+    if (typeof list === "string") {
+        return list.split(",").map(l => l.trim()).filter(l => !!l);
+    }
+    return [];
+}
+setTracingDisabled(true);
+export default class KnockAgent {
+    #loader;
+    #providers;
+    #models;
+    #runner;
+    #agents;
+    #agentsConfig;
+    #defaultModel;
+    #defaultTemperature;
+    #liquid;
+    #tools;
+    constructor(config) {
+        // init fields
+        this.#runner = new Runner({
+            callModelInputFilter: this.#runnerModelInputFilter.bind(this),
+            tracingDisabled: true
+        });
+        this.#liquid = new Liquid({
+            strictFilters: true,
+            strictVariables: true,
+        });
+        this.#liquid.registerFilter("json", (v) => JSON.stringify(v));
+        this.#agentsConfig = new Map();
+        this.#agents = new Map();
+        this.#models = new Map();
+        this.#tools = new Map();
+        this.#loader = new Loader(config.rootDir, config.fs);
+        this.#defaultModel = config.defaultModel;
+        this.#defaultTemperature = config.defaultTemperature || 1.0;
+        this.#providers = config.providers;
+        if (config.tools && config.tools.length) {
+            for (let tool of config.tools) {
+                this.#tools.set(tool.name, tool);
+            }
+        }
+    }
+    #runnerModelInputFilter(input) {
+        const agentConfig = this.#agentsConfig.get(input.agent);
+        if (!agentConfig || !agentConfig.input || (!agentConfig.input.prefix && !agentConfig.input.suffix)) {
+            return input.modelData;
+        }
+        const modelInput = input.modelData.input;
+        const lastInput = modelInput[modelInput.length - 1];
+        if (!lastInput)
+            return input.modelData;
+        if ("role" in lastInput && lastInput.role === "user") {
+            let content = lastInput.content;
+            if (agentConfig.input.prefix) {
+                content = agentConfig.input.prefix + "\n\n" + content;
+            }
+            if (agentConfig.input.suffix) {
+                content = content + "\n\n" + agentConfig.input.suffix;
+            }
+            return {
+                instructions: input.modelData.instructions,
+                input: [...modelInput.slice(0, modelInput.length - 1), {
+                        role: "user",
+                        content: content
+                    }]
+            };
+        }
+        return input.modelData;
+    }
+    #getModel(model = this.#defaultModel, agentName) {
+        if (this.#models.has(model)) {
+            return this.#models.get(model);
+        }
+        const m = model.split("/");
+        const provider = m.shift();
+        const providerModel = m.join("/");
+        if (!this.#providers[provider]) {
+            throw new Error(`[KnockAgent] No Provider [${provider}] in agent [${agentName}]`);
+        }
+        const aiModel = this.#providers[provider].getModel(providerModel);
+        this.#models.set(model, aiModel);
+        return aiModel;
+    }
+    #getAgent(path) {
+        if (this.#agents.has(path)) {
+            return this.#agents.get(path);
+        }
+        const agentMeta = this.#loader.getAgent(path);
+        if (!agentMeta) {
+            console.warn(`[KnockAgent] Agent Name [${path}] Not Found`);
+            return null;
+        }
+        const data = agentMeta.data;
+        // Validation and Warnings
+        const warn = (field, expected, actual) => {
+            console.warn(`[KnockAgent] Agent [${path}] property "${field}" should be ${expected}, got ${typeof actual}`);
+        };
+        if (data.name !== undefined && typeof data.name !== "string")
+            warn("name", "string", data.name);
+        if (data.model !== undefined && typeof data.model !== "string")
+            warn("model", "string", data.model);
+        if (data.temperature !== undefined && typeof data.temperature !== "number" && typeof data.temperature !== "string")
+            warn("temperature", "number or string", data.temperature);
+        ["handoffs", "agents", "tools"].forEach(key => {
+            if (data[key] !== undefined && typeof data[key] !== "string" && !Array.isArray(data[key])) {
+                warn(key, "string or array", data[key]);
+            }
+        });
+        if (data.reasoning !== undefined) {
+            if (typeof data.reasoning !== "object" || data.reasoning === null) {
+                warn("reasoning", "object", data.reasoning);
+            }
+            else {
+                const r = data.reasoning;
+                if (r.effort !== undefined && typeof r.effort !== "string")
+                    warn("reasoning.effort", "string", r.effort);
+                if (r.summary !== undefined && typeof r.summary !== "string")
+                    warn("reasoning.summary", "string ('auto' | 'concise' | 'detailed')", r.summary);
+            }
+        }
+        if (data.input !== undefined) {
+            if (typeof data.input !== "object" || data.input === null) {
+                warn("input", "object", data.input);
+            }
+            else {
+                const i = data.input;
+                if (i.prefix !== undefined && typeof i.prefix !== "string")
+                    warn("input.prefix", "string", i.prefix);
+                if (i.suffix !== undefined && typeof i.suffix !== "string")
+                    warn("input.suffix", "string", i.suffix);
+            }
+        }
+        if (data.verbosity !== undefined && typeof data.verbosity !== "string")
+            warn("verbosity", "string", data.verbosity);
+        const agentDefineConfig = {
+            name: (typeof data.name === "string" ? data.name : "") || path.replace(/\//g, "_"),
+            desc: (typeof data.desc === "string" ? data.desc : (typeof data.description === "string" ? data.description : "")) || "",
+            model: (typeof data.model === "string" ? data.model : this.#defaultModel),
+            temperature: parseTemprature(data.temperature) ?? this.#defaultTemperature,
+            instructions: agentMeta.content,
+            handoffs: split(data.handoffs),
+            agents: split(data.agents),
+            tools: split(data.tools),
+        };
+        if (typeof data.reasoning === "object" && data.reasoning !== null) {
+            agentDefineConfig.reasoning = data.reasoning;
+        }
+        if (data.verbosity) {
+            agentDefineConfig.verbosity = data.verbosity;
+        }
+        if (typeof data.input === "object" && data.input !== null) {
+            agentDefineConfig.input = data.input;
+        }
+        const modelSettings = {
+            temperature: agentDefineConfig.temperature
+        };
+        if (agentDefineConfig.reasoning) {
+            modelSettings.reasoning = agentDefineConfig.reasoning;
+        }
+        if (agentDefineConfig.verbosity) {
+            modelSettings.text = { verbosity: agentDefineConfig.verbosity };
+        }
+        const model = this.#getModel(agentDefineConfig.model, path);
+        const agent = new Agent({
+            name: agentDefineConfig.name,
+            handoffDescription: agentDefineConfig.desc,
+            model,
+            modelSettings: model.mapModelSettings ? model.mapModelSettings(modelSettings) : modelSettings,
+            instructions: async (runContext) => {
+                const rawPrompt = await this.#liquid.parseAndRender(agentDefineConfig.instructions, runContext.context);
+                if (agentDefineConfig.handoffs.length) {
+                    return promptWithHandoffInstructions(rawPrompt);
+                }
+                return rawPrompt;
+            }
+        });
+        this.#agents.set(path, agent);
+        this.#agentsConfig.set(agent, agentDefineConfig);
+        if (agentDefineConfig.handoffs.length) {
+            agent.handoffs = agentDefineConfig.handoffs.map(h => this.#getAgent(h)).filter(a => !!a);
+        }
+        if (agentDefineConfig.agents.length || agentDefineConfig.tools.length) {
+            agent.tools = [...agentDefineConfig.agents.map(h => this.#getAgent(h)).filter(a => !!a).map(a => a.asTool({
+                    toolName: `agent_${a.name}`,
+                    toolDescription: a.handoffDescription,
+                })), ...agentDefineConfig.tools.map(t => this.#tools.get(t)).filter(t => !!t)];
+        }
+        return agent;
+    }
+    run(input, context = {}) {
+        return this.runAgent("main", input, context);
+    }
+    runAgent(agentPath, input, context = {}) {
+        const agent = this.#getAgent(agentPath);
+        if (!agent) {
+            throw new Error(`[KnockAgent] Agent [${agentPath}] Not Exists`);
+        }
+        return this.#runner.run(agent, input, {
+            context,
+            stream: true
+        });
+    }
+}

package/dist/Loader.d.ts

@@ -0,0 +1,13 @@
+import { type GrayMatterFile } from "gray-matter";
+export interface VirtualFS {
+    existsSync(path: string): boolean;
+    readFileSync(path: string, encoding?: BufferEncoding): string;
+    statSync(path: string): {
+        isFile(): boolean;
+    };
+}
+export default class Loader {
+    #private;
+    constructor(rootDir: string, fs?: VirtualFS);
+    getAgent(name: string): GrayMatterFile<string> | undefined;
+}

package/dist/Loader.js

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import matter from "gray-matter";
+export default class Loader {
+    #fs;
+    #rootDir;
+    #parsedCache = new Map();
+    constructor(rootDir, fs) {
+        this.#rootDir = path.resolve(rootDir);
+        this.#fs = fs ?? {
+            existsSync: (filePath) => existsSync(filePath),
+            readFileSync: (filePath, encoding = "utf-8") => readFileSync(filePath, encoding),
+            statSync: (filePath) => statSync(filePath)
+        };
+    }
+    getAgent(name) {
+        try {
+            const entryPath = this.#resolveEntryPath(name);
+            return this.#parseFile(entryPath, new Set());
+        }
+        catch (error) {
+            console.warn(`[Loader] Failed to load agent "${name}":`, error);
+            return undefined;
+        }
+    }
+    #parseFile(filePath, visiting) {
+        const normalized = path.normalize(filePath);
+        if (this.#parsedCache.has(normalized)) {
+            return this.#parsedCache.get(normalized);
+        }
+        if (visiting.has(normalized)) {
+            const cyclePath = [...visiting, normalized].join(" -> ");
+            throw new Error(`Circular reference detected: ${cyclePath}`);
+        }
+        visiting.add(normalized);
+        try {
+            const source = this.#fs.readFileSync(normalized, "utf-8");
+            const parsed = matter(source);
+            const resolvedContent = this.#resolveImports(parsed.content, normalized, visiting);
+            const resolvedPrompt = {
+                ...parsed,
+                content: resolvedContent
+            };
+            this.#parsedCache.set(normalized, resolvedPrompt);
+            return resolvedPrompt;
+        }
+        finally {
+            visiting.delete(normalized);
+        }
+    }
+    #resolveImports(content, currentFilePath, visiting) {
+        const importRegex = /@\(([^)]+)\)/g;
+        return content.replace(importRegex, (_full, importPath) => {
+            const targetPath = this.#resolveImportPath(currentFilePath, importPath.trim());
+            const importedPrompt = this.#parseFile(targetPath, visiting);
+            return importedPrompt.content;
+        });
+    }
+    #resolveEntryPath(name) {
+        const targetPath = path.resolve(this.#rootDir, name);
+        return this.#resolveMarkdownPath(targetPath, this.#rootDir);
+    }
+    #resolveImportPath(fromFilePath, importPath) {
+        if (!importPath) {
+            throw new Error("Import path cannot be empty");
+        }
+        let targetPath;
+        if (path.isAbsolute(importPath)) {
+            targetPath = path.resolve(this.#rootDir, `.${importPath}`);
+        }
+        else {
+            targetPath = path.resolve(path.dirname(fromFilePath), importPath);
+        }
+        return this.#resolveMarkdownPath(targetPath, this.#rootDir);
+    }
+    #resolveMarkdownPath(targetPath, baseDir) {
+        let resolvedPath = targetPath;
+        if (!resolvedPath.endsWith(".md")) {
+            resolvedPath += ".md";
+        }
+        this.#assertWithin(baseDir, resolvedPath);
+        this.#assertFileExists(resolvedPath);
+        return resolvedPath;
+    }
+    #assertWithin(baseDir, filePath) {
+        const normalizedBase = path.resolve(baseDir);
+        const normalizedTarget = path.resolve(filePath);
+        const targetRelative = path.relative(normalizedBase, normalizedTarget);
+        if (targetRelative === ".." || targetRelative.startsWith(`..${path.sep}`)) {
+            throw new Error(`Path escapes base directory: ${filePath}`);
+        }
+    }
+    #assertFileExists(filePath) {
+        if (!this.#fs.existsSync(filePath) || !this.#isFile(filePath)) {
+            throw new Error(`Markdown file not found: ${filePath}`);
+        }
+    }
+    #isFile(filePath) {
+        try {
+            return this.#fs.statSync(filePath).isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import KnockAgent from "./KnockAgent.ts";
+export default KnockAgent;
+export * from "./KnockAgent.ts";
+export * from "./utils.ts";
+export { VirtualFS } from "./Loader.ts";

package/dist/index.js

@@ -0,0 +1,4 @@
+import KnockAgent from "./KnockAgent.js";
+export default KnockAgent;
+export * from "./KnockAgent.js";
+export * from "./utils.js";

package/dist/tools/search.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare function createMoonshotSearch(apiKey: string): (config: {
+    model: string;
+    query: string;
+    deep?: boolean;
+}) => Promise<string | null>;
+export default function createSearchTool(config: {
+    openrouter?: {
+        apiKey: string;
+        engine?: "exa" | "native";
+        models: string[];
+    };
+    aliyun?: {
+        apiKey: string;
+        agent?: boolean;
+        models: string[];
+    };
+    moonshot?: {
+        apiKey: string;
+        models: string[];
+    };
+}): import("@openai/agents").FunctionTool<unknown, z.ZodObject<{
+    query: z.ZodString;
+    deep: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, string>;

package/dist/tools/search.js

@@ -0,0 +1,257 @@
+import { tool } from "@openai/agents";
+import { OpenRouter } from "@openrouter/sdk";
+import { z } from "zod";
+import OpenAI from "openai";
+function createOpenrouterSearch(apiKey, engine) {
+    function getSearchDeep(headers) {
+        if (!headers)
+            return "medium";
+        const h = new Headers(headers);
+        return h.get("x-search-deep") === "high" ? "high" : "medium";
+    }
+    function removeSearchDeep(headers) {
+        if (!headers)
+            return;
+        if (Array.isArray(headers)) {
+            headers = headers.filter(h => h[0] !== "x-search-deep");
+        }
+        else if (headers instanceof Headers) {
+            headers.delete("x-search-deep");
+        }
+        else {
+            delete headers["x-search-deep"];
+        }
+    }
+    const openrouter = new OpenRouter({
+        apiKey,
+        hooks: [{
+                beforeCreateRequest(_, request) {
+                    if (request.options) {
+                        const body = request.options.body;
+                        if (body && typeof body === "string") {
+                            const json = JSON.parse(body);
+                            json.web_search_options = {
+                                "search_context_size": getSearchDeep(request.options.headers)
+                            };
+                            request.options.body = JSON.stringify(json);
+                        }
+                        removeSearchDeep(request.options.headers);
+                    }
+                    return request;
+                }
+            }]
+    });
+    return async function search(config) {
+        const isPerplexity = config.model.toLowerCase().includes('perplexity');
+        const response = await openrouter.beta.responses.send({
+            openResponsesRequest: {
+                model: config.model,
+                instructions: "Please use a deep web search to find the user's question.",
+                input: config.query,
+                plugins: [{
+                        id: "web",
+                        enabled: true,
+                        engine: isPerplexity ? "native" : engine,
+                        maxResults: 5
+                    }]
+            }
+        }, {
+            headers: {
+                "x-search-deep": config.deep ? "high" : "medium"
+            }
+        });
+        if (response.output.length && response.output[0].type === "message" && response.output[0].content.length) {
+            const content = response.output[0].content[0];
+            if (content.type === "output_text") {
+                return content.text + "\n\n引用：\n\n" + content.annotations?.filter(a => a.type === "url_citation").map(a => `[${a.title}](${a.url})`).join("\n");
+            }
+        }
+        return null;
+    };
+}
+function createAliyunSearch(apiKey, agent) {
+    const searchStrategy = agent ? ["agent", "agent_max"] : ["turbo", "max"];
+    return async function search(config) {
+        const endpoint = (config.model.includes("qwen3.5") || config.model.includes("vl")) ? "multimodal-generation" : "text-generation";
+        const response = await fetch(`https://dashscope.aliyuncs.com/api/v1/services/aigc/${endpoint}/generation`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                model: config.model,
+                input: {
+                    messages: [
+                        { role: "user", content: config.query }
+                    ]
+                },
+                parameters: {
+                    enable_search: true,
+                    search_options: {
+                        search_strategy: config.deep ? searchStrategy[1] : searchStrategy[0],
+                        enable_source: true,
+                        forced_search: true,
+                        enable_citation: true,
+                        citation_format: "[ref_<number>]"
+                    },
+                    result_format: "message"
+                }
+            })
+        });
+        const data = await response.json();
+        if (data?.output?.choices?.length) {
+            const c = data.output.choices[0];
+            if (c.message) {
+                let content = "";
+                if (c.message.reasoning_content) {
+                    content += c.message.reasoning_content + "\n\n";
+                }
+                if (c.message.content) {
+                    content += c.message.content[0]?.text + "\n\n";
+                }
+                if (data.output.search_info?.search_results) {
+                    for (const result of data.output.search_info.search_results) {
+                        content += `ref_${result.index}: [${result.title}](${result.url})\n`;
+                    }
+                }
+                return content;
+            }
+        }
+        return null;
+    };
+}
+// test baseURL https://ark.cn-beijing.volces.com/api/v3
+// export function createVolcengineSearch(apiKey: string, baseURL: string) {
+//     return async function search(config: {
+//         model: string;
+//         query: string;
+//         deep?: boolean;
+//     }) {
+//         const response = await fetch(`${baseURL}/responses`, {
+//             method: "POST",
+//             headers: {
+//                 "Authorization": `Bearer ${apiKey}`,
+//                 "Content-Type": "application/json"
+//             },
+//             body: JSON.stringify({
+//                 model: config.model,
+//                 tools: [
+//                     {
+//                         type: "web_search",
+//                         max_keyword: 3,
+//                         sources: ["douyin", "moji", "toutiao"],
+//                         limit: config.deep ? 20 : 10
+//                     }
+//                 ],
+//                 max_tool_calls: config.deep ? 3 : 10,
+//                 input: [
+//                     {
+//                         role: "user",
+//                         content: config.query
+//                     }
+//                 ],
+//                 instructions: "Please use a deep web search to find the user's question.\nA web search was conducted on `date`. Incorporate the following web search results into your response.\nIMPORTANT: Cite them using markdown links named using the domain of the source.\nExample: [nytimes.com](https://nytimes.com/some-page)."
+//             })
+//         });
+//         console.log(await response.json());
+//     }
+// }
+// @todo need test
+export function createMoonshotSearch(apiKey) {
+    const client = new OpenAI({
+        apiKey,
+        baseURL: "https://api.moonshot.cn/v1"
+    });
+    return async function (config) {
+        let finishReason = null;
+        let content = null;
+        const messages = [
+            { "role": "system", "content": "Please use a deep web search to find the user's question.\nA web search was conducted on `date`. Incorporate the following web search results into your response.\nIMPORTANT: Cite them using markdown links named using the domain of the source.\nExample: [nytimes.com](https://nytimes.com/some-page)." },
+            { "role": "user", "content": "please web search: " + config.query } // 在提问中要求 Kimi 大模型联网搜索
+        ];
+        while (finishReason === null || finishReason === "tool_calls") {
+            const completion = await client.chat.completions.create({
+                model: config.model,
+                messages,
+                temperature: 0.6,
+                tools: [
+                    {
+                        // @ts-ignore
+                        "type": "builtin_function",
+                        "function": {
+                            "name": "$web_search",
+                        },
+                    }
+                ],
+            });
+            const choice = completion.choices[0];
+            finishReason = choice.finish_reason;
+            if (finishReason === "tool_calls") {
+                messages.push(choice.message);
+                for (const toolCall of choice.message.tool_calls || []) {
+                    // @ts-ignore
+                    const tool_call_name = toolCall.function.name;
+                    if (tool_call_name == "$web_search") {
+                        // @ts-ignore
+                        const tool_call_arguments = JSON.parse(toolCall.function.arguments);
+                        messages.push({
+                            "role": "tool",
+                            "tool_call_id": toolCall.id,
+                            //@ts-ignore
+                            "name": tool_call_name,
+                            "content": JSON.stringify(tool_call_arguments)
+                        });
+                    }
+                }
+            }
+            content = choice.message.content;
+            // console.log(choice.message.annotations);
+        }
+        return content;
+    };
+}
+export default function createSearchTool(config) {
+    const searchFns = [];
+    if (config.openrouter) {
+        const openrouterSearch = createOpenrouterSearch(config.openrouter.apiKey, config.openrouter.engine);
+        for (const model of config.openrouter.models) {
+            searchFns.push((query, deep) => openrouterSearch({
+                model,
+                query,
+                deep
+            }));
+        }
+    }
+    if (config.aliyun) {
+        const aliyunSearch = createAliyunSearch(config.aliyun.apiKey, config.aliyun.agent);
+        for (const model of config.aliyun.models) {
+            searchFns.push((query, deep) => aliyunSearch({
+                model,
+                query,
+                deep
+            }));
+        }
+    }
+    if (config.moonshot) {
+        const moonshotSearch = createMoonshotSearch(config.moonshot.apiKey);
+        for (const model of config.moonshot.models) {
+            searchFns.push((query, deep) => moonshotSearch({
+                model,
+                query,
+                deep
+            }));
+        }
+    }
+    return tool({
+        name: "search",
+        description: "Search the web for information",
+        parameters: z.object({
+            query: z.string().describe("The search query"),
+            deep: z.boolean().optional().describe("Whether to perform a deep search").default(false)
+        }),
+        execute: async ({ query, deep }) => {
+            return await Promise.all(searchFns.map(fn => fn(query, deep)));
+        }
+    });
+}

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+import { ModelSettings } from "@openai/agents";
+import { aisdk } from "@openai/agents-extensions";
+import { AiProvider } from "./KnockAgent.ts";
+export interface BaseAiProvider {
+    languageModel(modelName: string): Parameters<typeof aisdk>[0];
+}
+export interface MapModelSettings {
+    (modelSettings: ModelSettings, modelName: string): ModelSettings;
+}
+export declare function createAiProvider(baseProvider: BaseAiProvider, mapModelSettings?: MapModelSettings): AiProvider;

package/dist/utils.js

@@ -0,0 +1,40 @@
+import { aisdk } from "@openai/agents-extensions";
+/**
+ * A utility to handle values that might be promises.
+ * If the value is a promise, it waits for it and then applies the function.
+ * If it's not a promise, it applies the function immediately.
+ */
+function withPotentialPromise(value, callback) {
+    if (value instanceof Promise || (value && typeof value.then === "function")) {
+        return value.then(callback);
+    }
+    return callback(value);
+}
+export function createAiProvider(baseProvider, mapModelSettings) {
+    return {
+        getModel(modelName) {
+            const model = baseProvider.languageModel(modelName);
+            // Intercept getArgs to support passing extra body parameters through settings.extra
+            if (model && "getArgs" in model && typeof model.getArgs === "function") {
+                const originalGetArgs = model.getArgs;
+                model.getArgs = function (settings, ...args) {
+                    const result = originalGetArgs.apply(this, [settings, ...args]);
+                    return withPotentialPromise(result, (rawArgs) => {
+                        if (settings?.extra && rawArgs?.body) {
+                            rawArgs.body = {
+                                ...rawArgs.body,
+                                ...settings.extra,
+                            };
+                        }
+                        return rawArgs;
+                    });
+                };
+            }
+            const aiSdkModel = aisdk(model);
+            if (mapModelSettings) {
+                aiSdkModel.mapModelSettings = (modelSettings) => mapModelSettings(modelSettings, modelName);
+            }
+            return aiSdkModel;
+        },
+    };
+}