@inkeep/agents-run-api 0.39.4 → 0.40.0

package/dist/utils/artifact-component-schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from "@hono/zod-openapi";
+import { ArtifactComponentApiInsert, ArtifactComponentApiSelect, DataComponentInsert } from "@inkeep/agents-core";
+
+//#region src/utils/artifact-component-schema.d.ts
+
+/**
+ * Converts artifact component configurations to Zod schema for structured generation
+ */
+declare function createArtifactComponentsSchema(artifactComponents?: ArtifactComponentApiSelect[]): z.ZodObject<{}, z.core.$strip> | z.ZodUnion<any>;
+/**
+ * Standard artifact reference component schema for tool responses
+ */
+declare class ArtifactReferenceSchema {
+  private static readonly ARTIFACT_PROPS_SCHEMA;
+  /**
+   * Get the standard Zod schema for artifact reference components
+   */
+  static getSchema(): z.ZodType<any>;
+  /**
+   * Get complete DataComponent by adding missing fields to base definition
+   */
+  static getDataComponent(tenantId: string, projectId?: string): DataComponentInsert;
+}
+/**
+ * Standard artifact creation component schema for data components
+ */
+declare class ArtifactCreateSchema {
+  /**
+   * Generate artifact create schemas - one for each artifact component type
+   * @param artifactComponents - The available artifact components to generate schemas for
+   * @returns Array of Zod schemas, one for each artifact component
+   */
+  static getSchemas(artifactComponents: Array<ArtifactComponentApiInsert | ArtifactComponentApiSelect>): z.ZodType<any>[];
+  /**
+   * Get DataComponents for artifact creation - one for each artifact component type
+   * @param artifactComponents - The available artifact components to generate schemas for
+   * @returns Array of DataComponent definitions, one for each artifact component
+   */
+  static getDataComponents(tenantId: string, projectId: string | undefined, artifactComponents: Array<ArtifactComponentApiInsert | ArtifactComponentApiSelect>): DataComponentInsert[];
+}
+//#endregion
+export { ArtifactCreateSchema, ArtifactReferenceSchema, createArtifactComponentsSchema };

package/dist/utils/artifact-component-schema.js

@@ -0,0 +1,186 @@
+import { getLogger } from "../logger.js";
+import { jsonSchemaToZod } from "./data-component-schema.js";
+import { SchemaProcessor } from "./SchemaProcessor.js";
+import { z } from "@hono/zod-openapi";
+
+//#region src/utils/artifact-component-schema.ts
+getLogger("ArtifactComponentSchema");
+/**
+* Converts artifact component configurations to Zod schema for structured generation
+*/
+function createArtifactComponentsSchema(artifactComponents) {
+	const componentSchemas = artifactComponents?.map((component) => {
+		const propsSchema = jsonSchemaToZod(component.props ? removePreviewFlags(component.props) : {});
+		return z.object({
+			id: z.string().describe(component.id),
+			name: z.literal(component.name).describe(component.name),
+			props: propsSchema
+		}).describe(`${component.name}: ${component.description}`);
+	}) || [];
+	if (componentSchemas.length === 0) return z.object({});
+	if (componentSchemas.length === 1) return componentSchemas[0];
+	return z.union(componentSchemas);
+}
+/**
+* Remove inPreview flags from schema properties (for LLM consumption)
+*/
+function removePreviewFlags(schema) {
+	const cleanSchema = { ...schema };
+	if (cleanSchema.properties) {
+		const cleanProperties = {};
+		for (const [key, prop] of Object.entries(cleanSchema.properties)) {
+			const cleanProp = { ...prop };
+			delete cleanProp.inPreview;
+			cleanProperties[key] = cleanProp;
+		}
+		cleanSchema.properties = cleanProperties;
+	}
+	return cleanSchema;
+}
+/**
+* Standard artifact reference component schema for tool responses
+*/
+var ArtifactReferenceSchema = class ArtifactReferenceSchema {
+	static ARTIFACT_PROPS_SCHEMA = {
+		type: "object",
+		properties: {
+			artifact_id: {
+				type: "string",
+				description: "The artifact_id from your artifact:create tag. Must match exactly."
+			},
+			tool_call_id: {
+				type: "string",
+				description: "The EXACT tool_call_id from tool execution (call_xyz789 or toolu_abc123). NEVER invent or make up IDs."
+			}
+		},
+		required: ["artifact_id", "tool_call_id"]
+	};
+	/**
+	* Get the standard Zod schema for artifact reference components
+	*/
+	static getSchema() {
+		return z.object({
+			id: z.string(),
+			name: z.literal("Artifact"),
+			props: jsonSchemaToZod(ArtifactReferenceSchema.ARTIFACT_PROPS_SCHEMA)
+		});
+	}
+	/**
+	* Get complete DataComponent by adding missing fields to base definition
+	*/
+	static getDataComponent(tenantId, projectId = "") {
+		return {
+			id: "The artifact_id from your artifact:create tag. Must match exactly.",
+			tenantId,
+			projectId,
+			name: "Artifact",
+			description: "Reference to artifacts created from tool results that grounds information in verifiable sources.",
+			props: ArtifactReferenceSchema.ARTIFACT_PROPS_SCHEMA
+		};
+	}
+};
+/**
+* Standard artifact creation component schema for data components
+*/
+var ArtifactCreateSchema = class {
+	/**
+	* Generate artifact create schemas - one for each artifact component type
+	* @param artifactComponents - The available artifact components to generate schemas for
+	* @returns Array of Zod schemas, one for each artifact component
+	*/
+	static getSchemas(artifactComponents) {
+		return artifactComponents.map((component) => {
+			const enhancedSchema = component.props ? SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.props) : {
+				type: "object",
+				properties: {}
+			};
+			const propsSchema = {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						description: `Unique artifact identifier for ${component.name} (e.g., "${component.name.toLowerCase()}-1")`
+					},
+					tool_call_id: {
+						type: "string",
+						description: "The EXACT tool_call_id from tool execution (call_xyz789 or toolu_abc123). NEVER invent or make up IDs."
+					},
+					type: {
+						type: "string",
+						enum: [component.name],
+						description: `Artifact type - must be "${component.name}"`
+					},
+					base_selector: {
+						type: "string",
+						description: "JMESPath selector starting with \"result.\" to navigate to ONE specific item. Details selector will be relative to this selection. Use filtering to avoid arrays (e.g., \"result.items[?type=='guide']\")."
+					},
+					details_selector: enhancedSchema
+				},
+				required: [
+					"id",
+					"tool_call_id",
+					"type",
+					"base_selector"
+				]
+			};
+			return z.object({
+				id: z.string(),
+				name: z.literal(`ArtifactCreate_${component.name}`),
+				props: jsonSchemaToZod(propsSchema)
+			});
+		});
+	}
+	/**
+	* Get DataComponents for artifact creation - one for each artifact component type
+	* @param artifactComponents - The available artifact components to generate schemas for
+	* @returns Array of DataComponent definitions, one for each artifact component
+	*/
+	static getDataComponents(tenantId, projectId = "", artifactComponents) {
+		return artifactComponents.map((component) => {
+			const enhancedSchema = component.props ? SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.props) : {
+				type: "object",
+				properties: {}
+			};
+			const propsSchema = {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						description: `Unique artifact identifier for ${component.name} (e.g., "${component.name.toLowerCase()}-1")`
+					},
+					tool_call_id: {
+						type: "string",
+						description: "The EXACT tool_call_id from tool execution (call_xyz789 or toolu_abc123). NEVER invent or make up IDs."
+					},
+					type: {
+						type: "string",
+						enum: [component.name],
+						description: `Artifact type - must be "${component.name}"`
+					},
+					base_selector: {
+						type: "string",
+						description: "JMESPath selector starting with \"result.\" to navigate to ONE specific item. Details selector will be relative to this selection. Use filtering to avoid arrays (e.g., \"result.items[?type=='guide']\")."
+					},
+					details_selector: enhancedSchema
+				},
+				required: [
+					"id",
+					"tool_call_id",
+					"type",
+					"base_selector"
+				]
+			};
+			return {
+				id: `artifact-create-${component.name.toLowerCase().replace(/\s+/g, "-")}`,
+				tenantId,
+				projectId,
+				name: `ArtifactCreate_${component.name}`,
+				description: `Create ${component.name} artifacts from tool results by extracting structured data using selectors.`,
+				props: propsSchema
+			};
+		});
+	}
+};
+
+//#endregion
+export { ArtifactCreateSchema, ArtifactReferenceSchema, createArtifactComponentsSchema };

package/dist/utils/cleanup.d.ts

@@ -0,0 +1,21 @@
+//#region src/utils/cleanup.d.ts
+/**
+ * Cleanup utilities for gracefully shutting down resources
+ * Helps prevent Node.js processes from hanging
+ */
+/**
+ * Gracefully exit the process after cleaning up resources
+ */
+declare function gracefulExit(code?: number, delayMs?: number, message?: string): void;
+/**
+ * Setup signal handlers for graceful shutdown
+ */
+declare function setupGracefulShutdown(cleanupFn?: () => Promise<void> | void, exitDelayMs?: number): void;
+/**
+ * Stop all tools associated with agents
+ */
+declare function stopAllAgentTools(agents: Array<{
+  getTools: () => Record<string, any>;
+}>): Promise<void>;
+//#endregion
+export { gracefulExit, setupGracefulShutdown, stopAllAgentTools };

package/dist/utils/cleanup.js

@@ -0,0 +1,59 @@
+import { getLogger } from "../logger.js";
+
+//#region src/utils/cleanup.ts
+/**
+* Cleanup utilities for gracefully shutting down resources
+* Helps prevent Node.js processes from hanging
+*/
+const logger = getLogger("cleanup");
+/**
+* Gracefully exit the process after cleaning up resources
+*/
+function gracefulExit(code = 0, delayMs = 1e3, message) {
+	if (message) logger.info({}, message);
+	setTimeout(() => {
+		logger.debug({}, "Forcing process exit after cleanup delay");
+		process.exit(code);
+	}, delayMs);
+}
+/**
+* Setup signal handlers for graceful shutdown
+*/
+function setupGracefulShutdown(cleanupFn, exitDelayMs = 2e3) {
+	const signals = ["SIGTERM", "SIGINT"];
+	let isShuttingDown = false;
+	for (const signal of signals) process.on(signal, async () => {
+		if (isShuttingDown) {
+			logger.warn({}, `Received ${signal} during shutdown, forcing exit`);
+			process.exit(1);
+		}
+		logger.info({}, `Received ${signal}, starting graceful shutdown`);
+		isShuttingDown = true;
+		try {
+			if (cleanupFn) await cleanupFn();
+		} catch (error) {
+			logger.error({ error }, "Error during cleanup");
+		}
+		gracefulExit(0, exitDelayMs, "🚪 Graceful shutdown complete");
+	});
+}
+/**
+* Stop all tools associated with agents
+*/
+async function stopAllAgentTools(agents) {
+	logger.info({}, "Stopping all agent tools...");
+	for (const agent of agents) {
+		const tools = agent.getTools();
+		for (const toolInstance of Object.values(tools)) if (toolInstance && typeof toolInstance.stop === "function") try {
+			await toolInstance.stop();
+			const toolName = toolInstance.config?.name || "unknown";
+			logger.debug({}, `Stopped tool: ${toolName}`);
+		} catch (error) {
+			logger.warn({}, `Failed to stop tool: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+	}
+	logger.info({}, "All agent tools stopped");
+}
+
+//#endregion
+export { gracefulExit, setupGracefulShutdown, stopAllAgentTools };

package/dist/utils/data-component-schema.d.ts

@@ -0,0 +1,2 @@
+import { jsonSchemaToZod } from "@inkeep/agents-core";
+export { jsonSchemaToZod };

package/dist/utils/data-component-schema.js

@@ -0,0 +1,3 @@
+import { jsonSchemaToZod } from "@inkeep/agents-core";
+
+export { jsonSchemaToZod };

package/dist/utils/default-status-schemas.d.ts

@@ -0,0 +1,20 @@
+import { StatusComponent } from "@inkeep/agents-core";
+
+//#region src/utils/default-status-schemas.d.ts
+
+/**
+ * Schema for retrieve operations - when agents are looking up, searching,
+ * or researching information in web or downstream services
+ */
+declare const retrieveStatusSchema: StatusComponent;
+/**
+ * Schema for action operations - when agents are using tools or delegating
+ * tasks with side-effects to update, create, or modify downstream services
+ */
+declare const actionStatusSchema: StatusComponent;
+/**
+ * Default status component schemas collection
+ */
+declare const defaultStatusSchemas: StatusComponent[];
+//#endregion
+export { actionStatusSchema, defaultStatusSchemas, retrieveStatusSchema };

package/dist/utils/default-status-schemas.js

@@ -0,0 +1,24 @@
+//#region src/utils/default-status-schemas.ts
+/**
+* Schema for retrieve operations - when agents are looking up, searching,
+* or researching information in web or downstream services
+*/
+const retrieveStatusSchema = {
+	type: "retrieve",
+	description: "Use this when the system found or retrieved specific information from searches, queries, or lookups. ONLY report ACTUAL findings that appear explicitly in the tool results - never make up data, names, numbers, or details. The label must state the SPECIFIC discovery (e.g., \"Found 3 authentication methods\", \"Database contains 500 records\", \"API supports JSON format\") not the act of searching. Every detail must be traceable to actual tool output. NEVER invent placeholder names, fictional data, or information not present in the activities."
+};
+/**
+* Schema for action operations - when agents are using tools or delegating
+* tasks with side-effects to update, create, or modify downstream services
+*/
+const actionStatusSchema = {
+	type: "action",
+	description: "Use this when the system executed a tool or performed an operation that modified state or had side effects. ONLY report ACTUAL tool executions and their results as they appear in the tool outputs - never make up tool names, parameters, or outcomes. The label must describe what specific action was performed and its concrete result based on actual tool execution data. DO NOT make up examples like \"Ran test suite with X passes\" unless a test suite was ACTUALLY run and reported X passes. DO NOT say \"Executed database query\" unless a database query was ACTUALLY executed. Only report what literally happened. NEVER invent tool names, execution results, or details not explicitly present in the tool execution activities. If a tool failed, report the actual failure, not imagined success."
+};
+/**
+* Default status component schemas collection
+*/
+const defaultStatusSchemas = [retrieveStatusSchema, actionStatusSchema];
+
+//#endregion
+export { actionStatusSchema, defaultStatusSchemas, retrieveStatusSchema };

package/dist/utils/json-postprocessor.d.ts

@@ -0,0 +1,13 @@
+//#region src/utils/json-postprocessor.d.ts
+/**
+ * Simple post-processor to clean up common LLM JSON formatting issues
+ */
+declare function stripJsonCodeBlocks(text: string): string;
+/**
+ * Configuration helper to add JSON post-processing to generateObject calls
+ */
+declare function withJsonPostProcessing<T extends Record<string, any>>(config: T): T & {
+  experimental_transform?: (text: string) => string;
+};
+//#endregion
+export { stripJsonCodeBlocks, withJsonPostProcessing };

package/dist/{json-postprocessor.cjs → utils/json-postprocessor.js}

@@ -1,4 +1,3 @@
-
 //#region src/utils/json-postprocessor.ts
 /**
 * Simple post-processor to clean up common LLM JSON formatting issues
@@ -17,4 +16,4 @@ function withJsonPostProcessing(config) {
 }
 
 //#endregion
-exports.withJsonPostProcessing = withJsonPostProcessing;
+export { stripJsonCodeBlocks, withJsonPostProcessing };

package/dist/utils/model-context-utils.d.ts

@@ -0,0 +1,39 @@
+import { ModelSettings } from "@inkeep/agents-core";
+
+//#region src/utils/model-context-utils.d.ts
+
+/**
+ * Get context window information for a model
+ */
+interface ModelContextInfo {
+  contextWindow: number | null;
+  hasValidContextWindow: boolean;
+  modelId: string;
+  source: 'llm-info' | 'fallback';
+}
+/**
+ * Extract model ID from model string for llm-info lookup
+ * Includes smart mapping to find dated versions for models that don't have exact matches
+ */
+declare function extractModelIdForLlmInfo(modelInput: string): string;
+declare function extractModelIdForLlmInfo(modelSettings?: ModelSettings): string | null;
+/**
+ * Get context window size for a model using llm-info
+ * Falls back to default values if model not found
+ */
+declare function getModelContextWindow(modelSettings?: ModelSettings): ModelContextInfo;
+/**
+ * Get compression configuration based on model context window
+ * Uses actual model context window when available, otherwise falls back to environment variables
+ * @param modelSettings - Model settings to get context window for
+ * @param targetPercentage - Target percentage of context window to use (e.g., 0.5 for conversation, undefined for model-aware defaults)
+ */
+declare function getCompressionConfigForModel(modelSettings?: ModelSettings, targetPercentage?: number): {
+  hardLimit: number;
+  safetyBuffer: number;
+  enabled: boolean;
+  source: string;
+  modelContextInfo: ModelContextInfo;
+};
+//#endregion
+export { ModelContextInfo, extractModelIdForLlmInfo, getCompressionConfigForModel, getModelContextWindow };

package/dist/utils/model-context-utils.js

@@ -0,0 +1,181 @@
+import { getLogger } from "../logger.js";
+import { COMPRESSION_ENABLED, COMPRESSION_HARD_LIMIT, COMPRESSION_SAFETY_BUFFER } from "../constants/execution-limits/index.js";
+import { ModelInfoMap } from "llm-info";
+
+//#region src/utils/model-context-utils.ts
+const logger = getLogger("ModelContextUtils");
+function extractModelIdForLlmInfo(modelInput) {
+	let modelString;
+	if (typeof modelInput === "string") {
+		modelString = modelInput.trim();
+		if (!modelString) return null;
+	} else if (modelInput?.model) {
+		modelString = modelInput.model.trim();
+		if (!modelString) return null;
+	} else return null;
+	let modelId;
+	if (modelString.includes("/")) {
+		const parts = modelString.split("/");
+		modelId = parts[parts.length - 1];
+	} else modelId = modelString;
+	if (modelId in ModelInfoMap) return modelId;
+	const matchingModels = Object.keys(ModelInfoMap).filter((key) => key.startsWith(modelId));
+	if (matchingModels.length > 0) return matchingModels.sort().reverse()[0];
+	return modelId;
+}
+/**
+* Get context window size for a model using llm-info
+* Falls back to default values if model not found
+*/
+function getModelContextWindow(modelSettings) {
+	const defaultContextWindow = 12e4;
+	if (!modelSettings?.model) {
+		logger.debug({}, "No model settings provided, using fallback");
+		return {
+			contextWindow: defaultContextWindow,
+			hasValidContextWindow: false,
+			modelId: "unknown",
+			source: "fallback"
+		};
+	}
+	const modelId = extractModelIdForLlmInfo(modelSettings);
+	if (!modelId) {
+		logger.debug({ modelString: modelSettings.model }, "Could not extract model ID for llm-info lookup");
+		return {
+			contextWindow: defaultContextWindow,
+			hasValidContextWindow: false,
+			modelId: modelSettings.model,
+			source: "fallback"
+		};
+	}
+	try {
+		const modelDetails = ModelInfoMap[modelId];
+		if (modelDetails && modelDetails.contextWindowTokenLimit && modelDetails.contextWindowTokenLimit > 0) {
+			logger.debug({
+				modelId,
+				contextWindow: modelDetails.contextWindowTokenLimit,
+				originalModel: modelSettings.model
+			}, "Found context window from llm-info");
+			return {
+				contextWindow: modelDetails.contextWindowTokenLimit,
+				hasValidContextWindow: true,
+				modelId,
+				source: "llm-info"
+			};
+		}
+		logger.debug({
+			modelId,
+			modelDetails,
+			originalModel: modelSettings.model
+		}, "No valid context window found in llm-info");
+	} catch (error) {
+		logger.debug({
+			modelId,
+			error: error instanceof Error ? error.message : String(error),
+			originalModel: modelSettings.model
+		}, "Error getting model details from llm-info");
+	}
+	logger.debug({
+		modelId,
+		defaultContextWindow
+	}, "Using fallback context window");
+	return {
+		contextWindow: defaultContextWindow,
+		hasValidContextWindow: false,
+		modelId,
+		source: "fallback"
+	};
+}
+/**
+* Get model-size aware compression parameters
+* Uses aggressive thresholds for better utilization, especially on large models
+*/
+function getCompressionParams(contextWindow) {
+	if (contextWindow < 1e5) return {
+		threshold: .85,
+		bufferPct: .1
+	};
+	if (contextWindow < 5e5) return {
+		threshold: .9,
+		bufferPct: .07
+	};
+	return {
+		threshold: .95,
+		bufferPct: .04
+	};
+}
+/**
+* Get compression configuration based on model context window
+* Uses actual model context window when available, otherwise falls back to environment variables
+* @param modelSettings - Model settings to get context window for
+* @param targetPercentage - Target percentage of context window to use (e.g., 0.5 for conversation, undefined for model-aware defaults)
+*/
+function getCompressionConfigForModel(modelSettings, targetPercentage) {
+	const modelContextInfo = getModelContextWindow(modelSettings);
+	const envHardLimit = parseInt(process.env.AGENTS_COMPRESSION_HARD_LIMIT || COMPRESSION_HARD_LIMIT.toString());
+	const envSafetyBuffer = parseInt(process.env.AGENTS_COMPRESSION_SAFETY_BUFFER || COMPRESSION_SAFETY_BUFFER.toString());
+	const enabled = process.env.AGENTS_COMPRESSION_ENABLED !== "false" && COMPRESSION_ENABLED;
+	if (modelContextInfo.hasValidContextWindow && modelContextInfo.contextWindow) {
+		let hardLimit;
+		let safetyBuffer;
+		let logContext;
+		if (targetPercentage !== void 0) {
+			hardLimit = Math.floor(modelContextInfo.contextWindow * targetPercentage);
+			safetyBuffer = Math.floor(modelContextInfo.contextWindow * .05);
+			const triggerPoint = hardLimit - safetyBuffer;
+			const triggerPercentage = (triggerPoint / modelContextInfo.contextWindow * 100).toFixed(1);
+			logContext = {
+				modelId: modelContextInfo.modelId,
+				contextWindow: modelContextInfo.contextWindow,
+				hardLimit,
+				safetyBuffer,
+				triggerPoint,
+				triggerPercentage: `${triggerPercentage}%`,
+				targetPercentage: `${(targetPercentage * 100).toFixed(1)}%`,
+				compressionType: targetPercentage <= .6 ? "conversation" : "mid-generation"
+			};
+			logger.info(logContext, "Using percentage-based compression configuration");
+		} else {
+			const params = getCompressionParams(modelContextInfo.contextWindow);
+			hardLimit = Math.floor(modelContextInfo.contextWindow * params.threshold);
+			safetyBuffer = Math.floor(modelContextInfo.contextWindow * params.bufferPct);
+			const triggerPoint = hardLimit - safetyBuffer;
+			const triggerPercentage = (triggerPoint / modelContextInfo.contextWindow * 100).toFixed(1);
+			logContext = {
+				modelId: modelContextInfo.modelId,
+				contextWindow: modelContextInfo.contextWindow,
+				hardLimit,
+				safetyBuffer,
+				triggerPoint,
+				triggerPercentage: `${triggerPercentage}%`,
+				threshold: params.threshold,
+				bufferPct: params.bufferPct
+			};
+			logger.info(logContext, "Using model-size aware compression configuration");
+		}
+		return {
+			hardLimit,
+			safetyBuffer,
+			enabled,
+			source: "model-specific",
+			modelContextInfo
+		};
+	}
+	const source = process.env.AGENTS_COMPRESSION_HARD_LIMIT ? "environment" : "default";
+	logger.debug({
+		modelId: modelContextInfo.modelId,
+		hardLimit: envHardLimit,
+		safetyBuffer: envSafetyBuffer,
+		source
+	}, "Using fallback compression configuration");
+	return {
+		hardLimit: envHardLimit,
+		safetyBuffer: envSafetyBuffer,
+		enabled,
+		source,
+		modelContextInfo
+	};
+}
+
+//#endregion
+export { extractModelIdForLlmInfo, getCompressionConfigForModel, getModelContextWindow };

package/dist/utils/model-resolver.d.ts

@@ -0,0 +1,6 @@
+import { Models, SubAgentSelect } from "@inkeep/agents-core";
+
+//#region src/utils/model-resolver.d.ts
+declare function resolveModelConfig(agentId: string, subAgent: SubAgentSelect): Promise<Models>;
+//#endregion
+export { resolveModelConfig };

package/dist/utils/model-resolver.js

@@ -0,0 +1,34 @@
+import dbClient_default from "../data/db/dbClient.js";
+import { getAgentById, getProject } from "@inkeep/agents-core";
+
+//#region src/utils/model-resolver.ts
+async function resolveModelConfig(agentId, subAgent) {
+	if (subAgent.models?.base?.model) return {
+		base: subAgent.models.base,
+		structuredOutput: subAgent.models.structuredOutput || subAgent.models.base,
+		summarizer: subAgent.models.summarizer || subAgent.models.base
+	};
+	const agent = await getAgentById(dbClient_default)({ scopes: {
+		tenantId: subAgent.tenantId,
+		projectId: subAgent.projectId,
+		agentId
+	} });
+	if (agent?.models?.base?.model) return {
+		base: agent.models.base,
+		structuredOutput: subAgent.models?.structuredOutput || agent.models.structuredOutput || agent.models.base,
+		summarizer: subAgent.models?.summarizer || agent.models.summarizer || agent.models.base
+	};
+	const project = await getProject(dbClient_default)({ scopes: {
+		tenantId: subAgent.tenantId,
+		projectId: subAgent.projectId
+	} });
+	if (project?.models?.base?.model) return {
+		base: project.models.base,
+		structuredOutput: subAgent.models?.structuredOutput || project.models.structuredOutput || project.models.base,
+		summarizer: subAgent.models?.summarizer || project.models.summarizer || project.models.base
+	};
+	throw new Error("Base model configuration is required. Please configure models at the project level.");
+}
+
+//#endregion
+export { resolveModelConfig };