pi-harness-runtime 1.1.49 → 1.1.71-3

package/harness/langchain/graph.ts

@@ -20,13 +20,15 @@ import {
 	StateGraph,
 } from "@langchain/langgraph";
 import {
-	autonomyDirective,
 	isAutonomyRequest,
+	autonomyDirective,
 	lastMessage,
 	type ReviewVerdict,
 	ReviewVerdictSchema,
 } from "./agents.js";
+import { readFileSync } from "node:fs";
 import { WriteReviewBlackboard } from "../../packages/write-review/src/blackboard.js";
+import { getApprovedPatternStore } from "../../packages/trajectory/src/index.js";
 import type { Verdict } from "../../packages/write-review/src/types.js";
 import type { LoopWidget } from "./widget.js";
 
@@ -51,6 +53,17 @@ const LoopState = Annotation.Root({
 		reducer: (prev, next) => [...(prev ?? []), ...(next ?? [])],
 		default: () => [],
 	}),
+	/** Code from the previous iteration. Used for stuck detection (P0-2). */
+	prevCode: Annotation<string | undefined>({
+		reducer: (_prev, next) => next,
+		default: () => undefined,
+	}),
+	/** Actual file contents written in the most recent write step.
+	 *  P1-1: used to pass real file contents to the reviewer instead of a summary. */
+	writtenFiles: Annotation<Record<string, string>>({
+		reducer: (_prev, next) => next,
+		default: () => ({}),
+	}),
 });
 
 export type LoopState = typeof LoopState.State;
@@ -60,7 +73,22 @@ export type LoopState = typeof LoopState.State;
 export interface LoopDeps {
 	plan: (request: string) => Promise<string>;
 	write: (plan: string, review: ReviewVerdict | null) => Promise<string>;
-	review: (plan: string, code: string) => Promise<ReviewVerdict>;
+	review: (
+		plan: string,
+		code: string,
+		writtenFiles?: Record<string, string>,
+	) => Promise<ReviewVerdict>;
+	/**
+	 * ADK ParallelAgent equivalent: run 3 specialist reviews in parallel.
+	 * If provided, reviewNode uses this instead of the monolithic review().
+	 * Specialists: security auditor + style auditor + performance analyst.
+	 * Takes ~1/3 the time of sequential reviews.
+	 */
+	parallelReview?: (
+		plan: string,
+		code: string,
+		writtenFiles?: Record<string, string>,
+	) => Promise<ReviewVerdict>;
 	maxIterations: number;
 	onStep?: (step: string, state: LoopState) => void;
 	/** Optional widget for TUI / status-line display (mirrors pi-lens footer style). */
@@ -81,18 +109,60 @@ function planNode(deps: LoopDeps) {
 	};
 }
 
+/** Extract file paths from a code string (mirrors blackboard.extractFilePaths). */
+function extractFilePaths(code: string): string[] {
+	const files = new Set<string>();
+	const lines = code.split("\n");
+	for (const line of lines) {
+		const match = line.match(
+			/^```(?:typescript|ts|javascript|js|tsx|jsx|text)?\s*\/([^\s`]+)\s*$/,
+		);
+		if (match) {
+			const path = match[1].trim();
+			if (path && !path.includes(" ")) files.add(path);
+		}
+		const mdMatch = line.match(/^\*\*([^:*]+):\*\*/);
+		if (mdMatch) {
+			const path = mdMatch[1].trim();
+			if (
+				path &&
+				!path.includes(" ") &&
+				(path.includes("/") || path.endsWith(".ts") || path.endsWith(".js"))
+			) {
+				files.add(path);
+			}
+		}
+	}
+	return [...files];
+}
+
 function writeNode(deps: LoopDeps) {
 	return async (state: LoopState): Promise<Partial<LoopState>> => {
 		const code = await deps.write(state.plan, state.review ?? null);
 		const iter = state.iteration + 1;
 		deps.onStep?.("write", { ...state, iteration: iter });
+		// P1-1: read actual file contents so the reviewer sees real code, not a summary
+		const paths = extractFilePaths(code);
+		const writtenFiles: Record<string, string> = {};
+		for (const p of paths) {
+			try {
+				writtenFiles[p] = readFileSync(p, "utf8");
+			} catch {
+				// File may not exist yet (mkdir was pending); skip
+			}
+		}
 		const reviewNote = state.review
 			? ` (addressing ${state.review.comments.length} review comment(s))`
 			: "";
-		// Note: previous `review` stays in state on purpose — the coder reads its comments.
 		return {
 			code,
+			writtenFiles,
 			iteration: iter,
+			// Snapshot the code from the previous iteration (before it was
+			// overwritten).  routeAfterReview uses this to detect stuck: if the
+			// coder outputs identical content in two consecutive iterations, the
+			// loop terminates early instead of wasting another review cycle.
+			prevCode: state.code,
 			log: [`[write:${iter}] MiniMax wrote code${reviewNote}`],
 		};
 	};
@@ -100,7 +170,14 @@ function writeNode(deps: LoopDeps) {
 
 function reviewNode(deps: LoopDeps) {
 	return async (state: LoopState): Promise<Partial<LoopState>> => {
-		const review = await deps.review(state.plan, state.code);
+		// ADK ParallelAgent: use parallel review if available (3x faster)
+		// Falls back to sequential review for dry-run or when parallelReview is not wired.
+		const doReview = deps.parallelReview ?? deps.review;
+		const review = await doReview(
+			state.plan,
+			state.code,
+			state.writtenFiles ?? {},
+		);
 		deps.onStep?.("review", state);
 		return {
 			review,
@@ -109,15 +186,25 @@ function reviewNode(deps: LoopDeps) {
 	};
 }
 
-function finishNode() {
+function finishNode(maxIterations: number) {
 	return async (state: LoopState): Promise<Partial<LoopState>> => {
 		const verdict = state.review?.verdict ?? "blocked";
-		const reason =
-			verdict === "approved"
-				? "reviewer approved"
-				: verdict === "changes_requested"
-					? `max iterations (${state.iteration}) reached with changes still requested`
-					: "reviewer blocked the task";
+		const comments = state.review?.comments ?? [];
+		let reason: string;
+		if (verdict === "approved") {
+			reason = "reviewer approved";
+		} else if (verdict === "blocked") {
+			reason = "reviewer blocked the task";
+		} else if (state.iteration >= maxIterations) {
+			reason = `max iterations (${state.iteration}) reached with changes still requested`;
+		} else if (
+			comments.length > 0 &&
+			comments.every((c) => c.severity === "minor" || !c.severity)
+		) {
+			reason = `converged: only minor comments (${state.iteration})`;
+		} else {
+			reason = `stuck: changes still requested after ${state.iteration} iteration(s)`;
+		}
 		return {
 			log: [`[finish] ${state.iteration} iteration(s) — ${reason}`],
 		};
@@ -126,13 +213,28 @@ function finishNode() {
 
 // ─── Routing ────────────────────────────────────────────────────────────────
 
+/** Smart stop: loop terminates early when quality criteria are met. */
 function routeAfterReview(
 	state: LoopState,
 	maxIterations: number,
 ): "write" | "finish" {
 	const verdict = state.review?.verdict;
+	const comments = state.review?.comments ?? [];
+	// 1. Always finish on approved or blocked
 	if (verdict === "approved" || verdict === "blocked") return "finish";
+	// 2. Hard cap
 	if (state.iteration >= maxIterations) return "finish";
+	// 3. SMART STOP: only minor comments (≤2) — converge fast
+	const hasOnlyMinor = comments.every(
+		(c) => c.severity === "minor" || !c.severity,
+	);
+	if (hasOnlyMinor && comments.length <= 2) return "finish";
+	// 4. P0-2 STUCK DETECTION: if the coder produced identical output in consecutive
+	//    iterations, no progress is being made — terminate early instead of wasting
+	//    another review cycle
+	if (state.prevCode !== undefined && state.code === state.prevCode) {
+		return "finish";
+	}
 	return "write";
 }
 
@@ -148,7 +250,7 @@ export function buildWriteReviewLoop(
 		.addNode("planStep", planNode(deps))
 		.addNode("writeStep", writeNode(deps))
 		.addNode("reviewStep", reviewNode(deps))
-		.addNode("finishStep", finishNode())
+		.addNode("finishStep", finishNode(deps.maxIterations))
 		.addEdge(START, "planStep")
 		.addEdge("planStep", "writeStep")
 		.addEdge("writeStep", "reviewStep")
@@ -182,6 +284,15 @@ export interface RealLoopOptions {
 	onStep?: (step: string, state: LoopState) => void;
 	/** Directory for .write-review/blackboard. Defaults to process.cwd(). */
 	blackboardDir?: string;
+	/**
+	 * The request string. Used by the smart model router to determine which
+	 * models to use for planner / reviewer / coder roles.  Supports per-request
+	 * directives in the prompt:
+	 *   [planner: gpt]      [reviewer: GLM]     [coder: MiniMax]
+	 *   "Use GPT as master reviewer" is also recognised.
+	 * If omitted, defaults to env vars (PLANNER_*, GLM_*, MINIMAX_*).
+	 */
+	request?: string;
 	importAgents?: () => Promise<{
 		createPlannerAgent: () => {
 			invoke: (input: { messages: unknown[] }) => Promise<{
@@ -214,9 +325,27 @@ export async function buildRealLoopDeps(
 	options: RealLoopOptions = {},
 ): Promise<LoopDeps> {
 	const mod = await import("./agents.js");
-	const planner = mod.createPlannerAgent();
-	const coder = mod.createCoderAgent();
-	const reviewer = mod.createReviewerAgent();
+
+	// Smart model routing — parses [role: family] directives in the request.
+	// Falls back to env defaults if no directives present.
+	// eslint-disable-next-line @typescript-eslint/no-require-imports
+	const { routeRequestSmart } = require("./model-router.js");
+	const route = options.request ? routeRequestSmart(options.request) : undefined;
+
+	const plannerModelOpts = route?.planner;
+	const reviewerModelOpts = route?.reviewer;
+	const coderModelOpts = route?.coder;
+
+	const planner = mod.createPlannerAgent(plannerModelOpts);
+	const coder = mod.createCoderAgent(coderModelOpts);
+	const reviewer = mod.createReviewerAgent(reviewerModelOpts);
+
+	// ADK ParallelAgent: create 3 specialist reviewers for parallel execution
+	const specialists = {
+		security: mod.createSpecialistReviewer("security", reviewerModelOpts),
+		style: mod.createSpecialistReviewer("style", reviewerModelOpts),
+		performance: mod.createSpecialistReviewer("performance", reviewerModelOpts),
+	};
 
 	// Create and init the shared blackboard
 	const blackboard = new WriteReviewBlackboard(
@@ -228,9 +357,8 @@ export async function buildRealLoopDeps(
 		blackboard.init();
 	}
 
-	// Autonomy mode: computed inside plan(), stored for write()/review()
-	const _autonomous = false;
-	const _directive = "";
+	// Autonomy mode: set in plan() based on request content, reused by write()/review()
+	let _directive = "";
 
 	/** Inject scoreboard markdown into a user message. */
 	const withScoreboard = (msg: string) => {
@@ -238,6 +366,16 @@ export async function buildRealLoopDeps(
 		return msg + "\n\n## Current Progress\n" + scoreboard;
 	};
 
+	/** Inject scoreboard + approved patterns into a user message (for the reviewer). */
+	const withReviewContext = (msg: string) => {
+		const scoreboard = blackboard.toMarkdown();
+		const patterns = getApprovedPatternStore().toMarkdown();
+		const parts = [msg];
+		if (scoreboard) parts.push("\n\n## Current Progress\n" + scoreboard);
+		if (patterns) parts.push("\n\n" + patterns);
+		return parts.join("");
+	};
+
 	// Wrap onStep to also update the blackboard
 	const originalOnStep = options.onStep;
 	const onStep = (step: string, state: LoopState) => {
@@ -280,14 +418,17 @@ export async function buildRealLoopDeps(
 	return {
 		maxIterations: options.maxIterations ?? 3,
 		onStep,
-		plan: async (request) =>
-			lastMessage(
+		plan: async (request) => {
+			// P1-2: detect autonomy signal in the request and unlock full autonomous mode
+			_directive = isAutonomyRequest(request) ? autonomyDirective() : "";
+			return lastMessage(
 				await planner.invoke({
 					messages: [
 						{ role: "user", content: _directive + withScoreboard(request) },
 					],
 				}),
-			),
+			);
+		},
 		write: async (plan, review) => {
 			const userMsg = review
 				? `## Plan\n${plan}\n\n## Review comments to address\n${review.comments
@@ -302,14 +443,20 @@ export async function buildRealLoopDeps(
 				}),
 			);
 		},
-		review: async (plan, code) => {
+		review: async (plan, _code, writtenFiles = {}) => {
+			// P1-1: build a code-to-review section from actual file contents
+			const codeSection =
+				Object.keys(writtenFiles).length > 0
+					? Object.entries(writtenFiles)
+							.map(([path, content]) => `## ${path}\n\n\`\`\`\n${content}\n\`\`\``)
+							.join("\n\n")
+					: `## Code\n\n\`\`\`\n${_code}\n\`\`\``;
 			const result = await reviewer.invoke({
 				messages: [
 					{
 						role: "user",
 						content:
-							_directive +
-							withScoreboard(`## Plan\n${plan}\n\n## Code to review\n${code}`),
+							_directive + withReviewContext(`## Plan\n${plan}\n\n${codeSection}`),
 					},
 				],
 			});
@@ -325,6 +472,9 @@ export async function buildRealLoopDeps(
 				};
 			}
 		},
+		// ADK ParallelAgent: 3 specialists run in parallel via Promise.all
+		parallelReview: async (plan, _code, writtenFiles = {}) =>
+			mod.parallelReview(specialists, plan, _code, writtenFiles),
 	};
 }
 
@@ -406,7 +556,7 @@ export function buildDryRunDeps(
 				`\`\`\`ts\n// stub code, iteration ${writeCount}\nexport const plan = ${JSON.stringify(plan.slice(0, 60))};${fixNote}\n\`\`\``,
 			);
 		},
-		review: async (_plan, _code) => {
+		review: async (_plan, _code, _writtenFiles = {}) => {
 			if (writeCount < 2) {
 				return {
 					verdict: "changes_requested",
@@ -415,7 +565,7 @@ export function buildDryRunDeps(
 						{
 							file: "index.ts",
 							comment: "dry-run: rename the exported constant",
-							severity: "minor",
+							severity: "major",
 						},
 					],
 				};
@@ -426,5 +576,13 @@ export function buildDryRunDeps(
 				comments: [],
 			};
 		},
+		// Dry-run parallel review: same deterministic stub (no LLM calls)
+		parallelReview: async (_plan, _code, _writtenFiles = {}) => {
+			return buildDryRunDeps({ maxIterations: options.maxIterations }).review(
+				"",
+				"",
+				{},
+			);
+		},
 	};
 }

package/harness/langchain/model-router.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Smart model router — reads the request prompt and decides which model to use
+ * for each agent role at runtime. No hardcoded model IDs; all choices are driven
+ * by env vars + optional per-request directives in the prompt.
+ *
+ * Per-request directives (optional — fallback to env defaults if absent):
+ *
+ *   Planner directive:
+ *     [planner: gpt-5.6]   or  [planner: GLM-5.2]   or  [planner: MiniMax-M2]
+ *
+ *   Reviewer directive (master reviewer — GLM is the design default):
+ *     [reviewer: GLM-5.2]  or  [reviewer: GPT-5.6]
+ *
+ *   Coder directive:
+ *     [coder: MiniMax-M2]   or  [coder: gpt-5.6]
+ *
+ *   Examples in a prompt:
+ *     "Implement X   [reviewer: GPT-5.6]  [planner: GLM-5.2]"
+ *     "Use GLM as master reviewer for this task"
+ *     "GPT as reviewer: please review this code"
+ *
+ *   The parser is forgiving — these all work:
+ *     [reviewer: GLM]        → uses GLM_MODEL from env
+ *     [reviewer: gpt]         → uses PLANNER_MODEL from env (same family)
+ *     [reviewer: MiniMax]     → uses MINIMAX_MODEL from env
+ *
+ * Wiki: wiki/multi-agent-langchain.md
+ */
+/** Model options derived from a resolved env prefix. */
+export interface ResolvedModel {
+    model: string;
+    baseURL: string;
+    apiKey: string;
+}
+/** Result of routing a request to models. */
+export interface RouteResult {
+    planner: ResolvedModel;
+    reviewer: ResolvedModel;
+    coder: ResolvedModel;
+    /** Text of the request with directive comments stripped (safe for agent prompts). */
+    cleanRequest: string;
+}
+/**
+ * Resolve a model family to actual env-backed model options.
+ * family: "GLM" | "PLANNER" | "MINIMAX" (case-insensitive input)
+ */
+export declare function resolveModel(family: string): ResolvedModel;
+/**
+ * Route a request prompt to the correct model configuration.
+ *
+ * Algorithm:
+ * 1. Extract [role: family] directives from the prompt
+ * 2. Resolve each family to actual env-backed model options
+ * 3. Apply defaults (planner→PLANNER, reviewer→GLM, coder→MINIMAX)
+ * 4. Strip directive comments from the request before passing to agents
+ */
+export declare function routeRequest(request: string): RouteResult;
+/**
+ * Route a request, also scanning natural-language hints.
+ * Directives ([role: family]) take precedence over natural hints.
+ */
+export declare function routeRequestSmart(request: string): RouteResult;
+//# sourceMappingURL=model-router.d.ts.map

package/harness/langchain/model-router.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model-router.test.d.ts.map

package/harness/langchain/model-router.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import {
+	routeRequest,
+	routeRequestSmart,
+	resolveModel,
+} from "./model-router.js";
+
+const TEST_ENV = {
+	PLANNER_API_KEY: "pk-test-planner",
+	PLANNER_MODEL: "gpt-5.6",
+	PLANNER_BASE_URL: "https://api.openai.com/v1",
+	GLM_API_KEY: "pk-test-glm",
+	GLM_MODEL: "GLM-5.2",
+	GLM_BASE_URL: "https://api.z.ai/api/v1",
+	MINIMAX_API_KEY: "pk-test-minimax",
+	MINIMAX_MODEL: "MiniMax-M2",
+	MINIMAX_BASE_URL: "https://api.minimaxi.com/v1",
+};
+
+describe("resolveModel", () => {
+	const original = process.env;
+
+	beforeEach(() => {
+		process.env = { ...original, ...TEST_ENV };
+	});
+
+	afterEach(() => {
+		process.env = original;
+	});
+
+	it("resolves GLM family from env", () => {
+		const r = resolveModel("glm");
+		assert.equal(r.model, "GLM-5.2");
+		assert.equal(r.baseURL, "https://api.z.ai/api/v1");
+		assert.equal(r.apiKey, "pk-test-glm");
+	});
+
+	it("resolves PLANNER family from env", () => {
+		const r = resolveModel("planner");
+		assert.equal(r.model, "gpt-5.6");
+		assert.equal(r.apiKey, "pk-test-planner");
+	});
+
+	it("resolves MINIMAX family from env", () => {
+		const r = resolveModel("minimax");
+		assert.equal(r.model, "MiniMax-M2");
+		assert.equal(r.apiKey, "pk-test-minimax");
+	});
+
+	it("is case-insensitive", () => {
+		const r = resolveModel("GLM");
+		assert.equal(r.model, "GLM-5.2");
+	});
+
+	it("throws if API key is missing", () => {
+		delete process.env.GLM_API_KEY;
+		assert.throws(() => resolveModel("glm"), /GLM_API_KEY is not set/);
+	});
+
+	it("throws if MODEL is missing", () => {
+		delete process.env.GLM_MODEL;
+		assert.throws(() => resolveModel("glm"), /GLM_MODEL is not set/);
+	});
+
+	it("throws if BASE_URL is missing", () => {
+		delete process.env.GLM_BASE_URL;
+		assert.throws(() => resolveModel("glm"), /GLM_BASE_URL is not set/);
+	});
+});
+
+describe("routeRequest", () => {
+	const original = process.env;
+
+	beforeEach(() => {
+		process.env = { ...original, ...TEST_ENV };
+	});
+
+	afterEach(() => {
+		process.env = original;
+	});
+
+	it("default: planner→PLANNER, reviewer→GLM, coder→MINIMAX", () => {
+		const r = routeRequest("Implement a rate limiter");
+		assert.equal(r.planner.model, "gpt-5.6");
+		assert.equal(r.reviewer.model, "GLM-5.2");
+		assert.equal(r.coder.model, "MiniMax-M2");
+		assert.equal(r.cleanRequest, "Implement a rate limiter");
+	});
+
+	it("strips [role: family] directives from cleanRequest", () => {
+		const r = routeRequest(
+			"Fix the bug  [planner: gpt]  [reviewer: GLM]  [coder: MiniMax]",
+		);
+		assert.equal(r.cleanRequest, "Fix the bug");
+	});
+
+	it("override reviewer with GPT directive → PLANNER env", () => {
+		const r = routeRequest("Implement feature X  [reviewer: gpt]");
+		assert.equal(r.reviewer.model, "gpt-5.6");
+		assert.equal(r.cleanRequest, "Implement feature X");
+	});
+
+	it("override planner with GLM directive", () => {
+		const r = routeRequest("Plan this task  [planner: glm]");
+		assert.equal(r.planner.model, "GLM-5.2");
+	});
+
+	it("override coder with GPT directive → PLANNER env", () => {
+		const r = routeRequest("Write the code  [coder: gpt]");
+		assert.equal(r.coder.model, "gpt-5.6");
+	});
+
+	it("multiple directives together", () => {
+		const r = routeRequest(
+			"Implement X  [planner: gpt]  [reviewer: GLM]  [coder: MiniMax]",
+		);
+		assert.equal(r.planner.model, "gpt-5.6");
+		assert.equal(r.reviewer.model, "GLM-5.2");
+		assert.equal(r.coder.model, "MiniMax-M2");
+	});
+
+	it("partial directive — only reviewer overridden", () => {
+		const r = routeRequest("Do it  [reviewer: gpt]");
+		assert.equal(r.reviewer.model, "gpt-5.6");
+		assert.equal(r.planner.model, "gpt-5.6");
+		assert.equal(r.coder.model, "MiniMax-M2");
+	});
+
+	it("unknown family throws — must be a recognised family name", () => {
+		// FAMILY_MAP only knows: gpt, glm, minimax
+		// unknown families are passed through as-is, causing readEnv to throw
+		assert.throws(
+			() => routeRequest("Do it  [reviewer: unknown-provider]"),
+			/UNKNOWN-PROVIDER_API_KEY is not set/,
+		);
+	});
+});
+
+describe("routeRequestSmart — natural language hints", () => {
+	const original = process.env;
+
+	beforeEach(() => {
+		process.env = { ...original, ...TEST_ENV };
+	});
+
+	afterEach(() => {
+		process.env = original;
+	});
+
+	it("'use GLM as master reviewer' → reviewer→GLM", () => {
+		const r = routeRequestSmart(
+			"Implement a rate limiter. Use GLM as master reviewer.",
+		);
+		assert.equal(r.reviewer.model, "GLM-5.2");
+	});
+
+	it("'use GPT as reviewer' → reviewer→PLANNER", () => {
+		const r = routeRequestSmart("Implement a rate limiter. Use GPT as reviewer.");
+		assert.equal(r.reviewer.model, "gpt-5.6");
+	});
+
+	it("'[reviewer: GLM]' directive beats natural hint", () => {
+		const r = routeRequestSmart(
+			"Implement X. Use GPT as master reviewer.  [reviewer: GLM]",
+		);
+		// directive wins
+		assert.equal(r.reviewer.model, "GLM-5.2");
+		assert.equal(r.cleanRequest, "Implement X. Use GPT as master reviewer.");
+	});
+
+	it("'GPT as planner' → planner→PLANNER", () => {
+		const r = routeRequestSmart("Plan the implementation. GPT as planner.");
+		assert.equal(r.planner.model, "gpt-5.6");
+	});
+
+	it("strips directive comments but keeps natural hints", () => {
+		const r = routeRequestSmart(
+			"Fix the bug. Use GLM as master reviewer.  [reviewer: gpt]",
+		);
+		assert.equal(r.cleanRequest, "Fix the bug. Use GLM as master reviewer.");
+		assert.equal(r.reviewer.model, "gpt-5.6"); // directive wins
+	});
+
+	it("defaults all three when no hints or directives", () => {
+		const r = routeRequestSmart("Just do it.");
+		assert.equal(r.planner.model, "gpt-5.6");
+		assert.equal(r.reviewer.model, "GLM-5.2");
+		assert.equal(r.coder.model, "MiniMax-M2");
+	});
+});