@case-framework/survey-assistant 0.2.3 → 0.4.0

package/dist/server-runtime.mjs

@@ -1,11 +1,122 @@
 import { n as SURVEY_ASSISTANT_TASK_AGENT_ID, t as SURVEY_ASSISTANT_AGENT_ID } from "./constants-CFUWrRtl.mjs";
 import { n as SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS } from "./request-guardrails-h4t6u8mP.mjs";
-import { i as createSurveyAssistantChatHandler, n as createSurveyAssistantThreadHandlers, r as SurveyAssistantAuthorizationError, t as createMastraMemoryThreadRepository } from "./memory-thread-repository-acbz6HZJ.mjs";
-import { t as SURVEY_ASSISTANT_TOOL_IDS } from "./tools-GDd5_GUh.mjs";
+import { i as createSurveyAssistantChatHandler, n as createSurveyAssistantThreadHandlers, r as SurveyAssistantAuthorizationError, t as createMastraMemoryThreadRepository } from "./memory-thread-repository-xBZOog_q.mjs";
+import { t as SURVEY_ASSISTANT_TOOL_IDS } from "./tools-TXI8bfzZ.mjs";
 import { SURVEY_ASSISTANT_OBSERVATIONAL_MEMORY_DEFAULTS, createSurveyAssistantAgent, createSurveyAssistantObservationalMemoryOptions } from "./server-agent.mjs";
 import { createSurveyAssistantTaskAgent, createSurveyAssistantTaskHandler } from "./server-tasks.mjs";
+import { z } from "zod";
 import { AzureOpenAIGateway } from "@mastra/core/llm";
 //#region src/server/runtime-config.ts
+const ENVIRONMENT_VARIABLE_NAME = /^[A-Z_][A-Z0-9_]*$/;
+const modelRoleSchema = z.enum([
+	"chat-default",
+	"chat-picker",
+	"memory",
+	"task-default"
+]);
+const providerModelOptionsSchema = z.object({
+	parallelToolCalls: z.boolean().optional(),
+	promptCacheKey: z.string().trim().min(1).optional(),
+	promptCacheRetention: z.enum(["in_memory", "24h"]).optional(),
+	reasoningEffort: z.string().trim().min(1).optional(),
+	reasoningSummary: z.enum([
+		"auto",
+		"concise",
+		"detailed",
+		"off",
+		"none"
+	]).optional(),
+	serviceTier: z.enum([
+		"auto",
+		"flex",
+		"priority",
+		"default"
+	]).optional(),
+	textVerbosity: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).optional()
+}).strict();
+const configuredModelSchema = z.object({
+	id: z.string().trim().min(1).max(240),
+	label: z.string().trim().min(1).max(240).optional(),
+	upstreamModel: z.string().trim().min(1).max(240).optional(),
+	roles: z.array(modelRoleSchema).min(1),
+	options: providerModelOptionsSchema.optional()
+}).strict().superRefine(({ roles }, context) => {
+	if (new Set(roles).size !== roles.length) context.addIssue({
+		code: "custom",
+		message: "Model roles must be unique."
+	});
+});
+const providerBaseShape = {
+	apiKeyEnv: z.string().regex(ENVIRONMENT_VARIABLE_NAME).optional(),
+	models: z.array(configuredModelSchema).min(1),
+	options: providerModelOptionsSchema.optional()
+};
+const providerSchema = z.discriminatedUnion("type", [
+	z.object({
+		...providerBaseShape,
+		type: z.literal("openai"),
+		apiKeyEnv: z.string().regex(ENVIRONMENT_VARIABLE_NAME)
+	}).strict(),
+	z.object({
+		...providerBaseShape,
+		type: z.literal("mistral"),
+		apiKeyEnv: z.string().regex(ENVIRONMENT_VARIABLE_NAME)
+	}).strict(),
+	z.object({
+		...providerBaseShape,
+		type: z.literal("lmstudio"),
+		baseUrl: z.string().url().default("http://127.0.0.1:1234/v1"),
+		apiKeyOptional: z.boolean().default(true)
+	}).strict(),
+	z.object({
+		...providerBaseShape,
+		type: z.literal("azure-openai"),
+		apiKeyEnv: z.string().regex(ENVIRONMENT_VARIABLE_NAME),
+		apiVersion: z.enum(["v1", "preview"]).default("v1"),
+		discoverModels: z.boolean().default(false),
+		resourceName: z.string().trim().min(1),
+		management: z.object({
+			tenantId: z.string().trim().min(1),
+			clientId: z.string().trim().min(1),
+			clientSecretEnv: z.string().regex(ENVIRONMENT_VARIABLE_NAME),
+			subscriptionId: z.string().trim().min(1),
+			resourceGroup: z.string().trim().min(1)
+		}).strict().optional()
+	}).strict()
+]);
+const surveyAssistantConfigurationDocumentSchema = z.object({
+	version: z.literal(1),
+	activeProvider: z.string().trim().min(1),
+	enabled: z.boolean().optional(),
+	providers: z.record(z.string().trim().min(1), providerSchema),
+	execution: z.object({
+		firstResponseTimeoutMs: z.number().int().positive().optional(),
+		idleTimeoutMs: z.number().int().positive().optional(),
+		maxConcurrentRequests: z.number().int().positive().optional(),
+		maxDurationMs: z.number().int().positive().optional(),
+		maxSteps: z.number().int().positive().optional(),
+		sendReasoning: z.boolean().optional()
+	}).strict().optional(),
+	memory: z.object({
+		enabled: z.boolean().optional(),
+		bufferOnIdle: z.boolean().optional(),
+		messageTokens: z.number().int().positive().optional(),
+		observationTokens: z.number().int().positive().optional(),
+		temporalMarkers: z.boolean().optional()
+	}).strict().optional(),
+	modelCatalogTtlMs: z.number().int().positive().optional(),
+	requestLimits: z.object({
+		maxAttachmentBytes: z.number().int().positive().optional(),
+		maxAttachments: z.number().int().positive().optional(),
+		maxRequestBytes: z.number().int().positive().optional(),
+		maxTextPartChars: z.number().int().positive().optional(),
+		maxTotalAttachmentBytes: z.number().int().positive().optional()
+	}).strict().optional()
+}).strict();
 const DEFAULT_MAX_STEPS = 48;
 const HARD_MAX_STEPS = 64;
 const DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = 900 * 1e3;
@@ -45,6 +156,26 @@ const getOptionalSameProviderModelId = (env, name, options) => {
 	return value ? getSameProviderModelId(value, name, options) : void 0;
 };
 const resolveSurveyAssistantProviderOptionsKey = (provider) => provider === "azure-openai" ? "azure" : provider;
+const createProviderOptions = (provider, options, sendReasoning) => {
+	const providerOptionsKey = resolveSurveyAssistantProviderOptionsKey(provider);
+	const reasoningSummary = options?.reasoningSummary === "off" || options?.reasoningSummary === "none" ? void 0 : options?.reasoningSummary;
+	const reasoningEffort = options?.reasoningEffort === "default" || options?.reasoningEffort === "provider-default" ? void 0 : options?.reasoningEffort;
+	const resolved = {
+		parallelToolCalls: options?.parallelToolCalls ?? false,
+		...reasoningEffort ? { reasoningEffort } : {},
+		...options?.promptCacheKey ? { promptCacheKey: options.promptCacheKey } : {},
+		...options?.promptCacheRetention ? { promptCacheRetention: options.promptCacheRetention } : {},
+		...sendReasoning && reasoningSummary ? { reasoningSummary } : {},
+		...options?.serviceTier ? { serviceTier: options.serviceTier } : {},
+		...options?.textVerbosity ? { textVerbosity: options.textVerbosity } : {}
+	};
+	return { [providerOptionsKey]: resolved };
+};
+const resolveConfiguredEnabled = (env, configured, requireExperimentalIdentityOptIn) => {
+	const environmentOverride = getValue(env, "SURVEY_ASSISTANT_ENABLED");
+	if (environmentOverride !== void 0 && environmentOverride !== "true" && environmentOverride !== "false") throw new Error("SURVEY_ASSISTANT_ENABLED must be \"true\" or \"false\".");
+	return (environmentOverride === "true" ? true : environmentOverride === "false" ? false : configured ?? env.NODE_ENV === "development") && (!requireExperimentalIdentityOptIn || env.NODE_ENV === "development" || getBoolean(env, "SURVEY_ASSISTANT_ALLOW_EXPERIMENTAL_IDENTITY", false));
+};
 const parseProvider = (env, fallback) => {
 	const value = getValue(env, "SURVEY_ASSISTANT_PROVIDER")?.toLowerCase();
 	if (value === "azure" || value === "azure-openai") return "azure-openai";
@@ -75,6 +206,139 @@ const getReadinessError = ({ azure, env, modelWasConfigured, provider, requireSt
 	}
 	return null;
 };
+const parseSurveyAssistantConfigurationDocument = (input, env, { requireExperimentalIdentityOptIn = false, requireStorage = true } = {}) => {
+	const document = surveyAssistantConfigurationDocumentSchema.parse(input);
+	const activeProvider = document.providers[document.activeProvider];
+	if (!activeProvider) throw new Error(`activeProvider references unknown provider "${document.activeProvider}".`);
+	const memoryEnabled = document.memory?.enabled ?? true;
+	for (const [providerName, configuredProvider] of Object.entries(document.providers)) {
+		const duplicateModelId = configuredProvider.models.find((model, index, models) => models.findIndex((candidate) => candidate.id === model.id) !== index)?.id;
+		if (duplicateModelId) throw new Error(`Provider "${providerName}" contains duplicate model id "${duplicateModelId}".`);
+		const modelsForProviderRole = (role) => configuredProvider.models.filter((model) => model.roles.includes(role));
+		const providerChatDefaults = modelsForProviderRole("chat-default");
+		const providerChatModels = modelsForProviderRole("chat-picker");
+		const providerTaskDefaults = modelsForProviderRole("task-default");
+		const providerMemoryModels = modelsForProviderRole("memory");
+		if (providerChatDefaults.length !== 1) throw new Error(`Provider "${providerName}" must configure exactly one chat-default model.`);
+		if (!providerChatDefaults[0].roles.includes("chat-picker")) throw new Error(`The chat-default model for provider "${providerName}" must also have the chat-picker role.`);
+		if (providerChatModels.length === 0) throw new Error(`Provider "${providerName}" must configure a chat-picker model.`);
+		if (providerTaskDefaults.length > 1) throw new Error(`Provider "${providerName}" may configure at most one task-default model.`);
+		if (providerMemoryModels.length > 1 || memoryEnabled && providerMemoryModels.length !== 1) throw new Error(memoryEnabled ? `Provider "${providerName}" must configure exactly one memory model when memory is enabled.` : `Provider "${providerName}" may configure at most one memory model.`);
+		if (configuredProvider.type === "lmstudio" && !configuredProvider.apiKeyOptional && !configuredProvider.apiKeyEnv) throw new Error(`Provider "${providerName}" must configure apiKeyEnv when apiKeyOptional is false.`);
+		const validateOptions = (options, location) => {
+			if (!options) return;
+			if (configuredProvider.type !== "openai" && configuredProvider.type !== "azure-openai" && (options.promptCacheKey || options.promptCacheRetention || options.reasoningSummary || options.textVerbosity)) throw new Error(`${location} contains options unsupported by ${configuredProvider.type}.`);
+			if (configuredProvider.type !== "openai" && options.serviceTier) throw new Error(`${location} contains serviceTier, which is only supported by openai.`);
+		};
+		validateOptions(configuredProvider.options, `Provider "${providerName}"`);
+		for (const model of configuredProvider.models) {
+			const upstreamModelId = model.upstreamModel ?? model.id;
+			if (configuredProvider.type !== "lmstudio" && upstreamModelId.includes("/")) throw new Error(`Model "${model.id}" must use an upstreamModel without a provider prefix for ${configuredProvider.type}.`);
+			validateOptions(model.options, `Model "${model.id}" in provider "${providerName}"`);
+		}
+	}
+	const modelsForRole = (role) => activeProvider.models.filter((model) => model.roles.includes(role));
+	const chatDefaults = modelsForRole("chat-default");
+	const chatModels = modelsForRole("chat-picker");
+	const taskDefaults = modelsForRole("task-default");
+	const memoryModels = modelsForRole("memory");
+	const provider = activeProvider.type;
+	const sendReasoning = document.execution?.sendReasoning ?? true;
+	const providerDefaults = {
+		parallelToolCalls: false,
+		...provider === "openai" || provider === "azure-openai" ? {
+			reasoningEffort: "low",
+			reasoningSummary: "detailed",
+			promptCacheKey: "survey-assistant-chat-v21"
+		} : provider === "mistral" ? { reasoningEffort: "none" } : {},
+		...activeProvider.options
+	};
+	const models = activeProvider.models.map((model) => ({
+		id: model.id,
+		label: model.label ?? model.id,
+		upstreamModelId: model.upstreamModel ?? model.id,
+		providerOptions: createProviderOptions(provider, {
+			...providerDefaults,
+			...model.options
+		}, sendReasoning)
+	}));
+	const configuredModel = (id) => models.find((model) => model.id === id);
+	const defaultModelId = chatDefaults[0].id;
+	const memoryModelId = (memoryModels[0] ?? chatDefaults[0]).id;
+	const taskModelId = taskDefaults[0]?.id;
+	const providerApiKey = activeProvider.apiKeyEnv ? getValue(env, activeProvider.apiKeyEnv) : void 0;
+	const memoryModel = configuredModel(memoryModelId);
+	const memoryModelConfig = provider === "lmstudio" ? {
+		providerId: "lmstudio",
+		modelId: memoryModel.upstreamModelId,
+		url: activeProvider.baseUrl,
+		...providerApiKey ? { apiKey: providerApiKey } : {}
+	} : provider === "azure-openai" ? `${provider}/${memoryModel.upstreamModelId}` : {
+		id: `${provider}/${memoryModel.upstreamModelId}`,
+		...providerApiKey ? { apiKey: providerApiKey } : {}
+	};
+	const azure = provider === "azure-openai" ? {
+		resourceName: activeProvider.resourceName,
+		apiKey: providerApiKey,
+		apiVersion: activeProvider.apiVersion,
+		discoverModels: activeProvider.discoverModels,
+		management: activeProvider.management ? {
+			tenantId: activeProvider.management.tenantId,
+			clientId: activeProvider.management.clientId,
+			clientSecret: getValue(env, activeProvider.management.clientSecretEnv) ?? "",
+			subscriptionId: activeProvider.management.subscriptionId,
+			resourceGroup: activeProvider.management.resourceGroup
+		} : void 0
+	} : void 0;
+	const lmstudio = provider === "lmstudio" ? {
+		baseUrl: activeProvider.baseUrl,
+		...providerApiKey ? { apiKey: providerApiKey } : {}
+	} : void 0;
+	const missingProviderSecret = activeProvider.apiKeyEnv && !providerApiKey && !(provider === "lmstudio" && activeProvider.apiKeyOptional);
+	const missingManagementSecret = provider === "azure-openai" && activeProvider.discoverModels && (!activeProvider.management || !azure?.management?.clientSecret);
+	const readinessError = requireStorage && !getValue(env, "SURVEY_ASSISTANT_DATABASE_URL") && !getValue(env, "DATABASE_URL") ? "Survey assistant storage is not configured." : missingProviderSecret ? `The provider credential ${activeProvider.apiKeyEnv} is not configured for the survey assistant.` : missingManagementSecret ? "Azure deployment discovery requires complete management configuration and credentials." : null;
+	const configuredMaxSteps = document.execution?.maxSteps ?? DEFAULT_MAX_STEPS;
+	return {
+		provider,
+		providerApiKey,
+		defaultModelId,
+		memoryModelId,
+		taskModelId,
+		modelIds: chatModels.map((model) => model.id),
+		models,
+		modelCatalogTtlMs: document.modelCatalogTtlMs ?? DEFAULT_CATALOG_TTL_MS,
+		azure,
+		lmstudio,
+		enabled: resolveConfiguredEnabled(env, document.enabled, requireExperimentalIdentityOptIn),
+		readinessError,
+		requestLimits: {
+			maxAttachmentBytes: document.requestLimits?.maxAttachmentBytes ?? SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS.maxAttachmentBytes,
+			maxAttachments: document.requestLimits?.maxAttachments ?? SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS.maxAttachments,
+			maxRequestBytes: document.requestLimits?.maxRequestBytes ?? SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS.maxRequestBytes,
+			maxTextPartChars: document.requestLimits?.maxTextPartChars ?? SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS.maxTextPartChars,
+			maxTotalAttachmentBytes: document.requestLimits?.maxTotalAttachmentBytes ?? SURVEY_ASSISTANT_DEFAULT_REQUEST_LIMITS.maxTotalAttachmentBytes
+		},
+		execution: {
+			firstResponseTimeoutMs: document.execution?.firstResponseTimeoutMs ?? DEFAULT_FIRST_RESPONSE_TIMEOUT_MS,
+			idleTimeoutMs: document.execution?.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS,
+			maxConcurrentRequests: document.execution?.maxConcurrentRequests ?? 4,
+			maxDurationMs: document.execution?.maxDurationMs ?? DEFAULT_MAX_DURATION_MS,
+			maxSteps: Math.min(configuredMaxSteps, HARD_MAX_STEPS),
+			providerOptions: configuredModel(defaultModelId).providerOptions,
+			sendReasoning
+		},
+		observationalMemory: memoryEnabled ? createSurveyAssistantObservationalMemoryOptions({
+			model: memoryModelConfig,
+			temporalMarkers: document.memory?.temporalMarkers ?? false,
+			observation: {
+				messageTokens: document.memory?.messageTokens ?? SURVEY_ASSISTANT_OBSERVATIONAL_MEMORY_DEFAULTS.messageTokens,
+				bufferOnIdle: document.memory?.bufferOnIdle ?? false,
+				observeAttachments: false
+			},
+			reflection: { observationTokens: document.memory?.observationTokens ?? SURVEY_ASSISTANT_OBSERVATIONAL_MEMORY_DEFAULTS.observationTokens }
+		}) : false
+	};
+};
 const parseSurveyAssistantEnvironment = (env, { defaultLmStudioModel, defaultMistralModel = "mistral-medium-latest", defaultOpenAIModel = "gpt-5.4-nano", defaultProvider = "openai", requireExperimentalIdentityOptIn = false, requireStorage = true } = {}) => {
 	const provider = parseProvider(env, defaultProvider);
 	const modelIdOptions = { allowNestedId: provider === "lmstudio" };
@@ -122,7 +386,7 @@ const parseSurveyAssistantEnvironment = (env, { defaultLmStudioModel, defaultMis
 	const azure = provider === "azure-openai" ? {
 		resourceName: getValue(env, "AZURE_RESOURCE_NAME"),
 		apiKey: getValue(env, "AZURE_API_KEY"),
-		apiVersion: getValue(env, "SURVEY_ASSISTANT_AZURE_API_VERSION") ?? "v1",
+		apiVersion: getEnum(env, "SURVEY_ASSISTANT_AZURE_API_VERSION", ["v1", "preview"]) ?? "v1",
 		discoverModels: getBoolean(env, "SURVEY_ASSISTANT_AZURE_DISCOVER_MODELS", false),
 		management: parseAzureManagement(env)
 	} : void 0;
@@ -130,8 +394,14 @@ const parseSurveyAssistantEnvironment = (env, { defaultLmStudioModel, defaultMis
 		baseUrl: getValue(env, "SURVEY_ASSISTANT_LMSTUDIO_BASE_URL") ?? "http://127.0.0.1:1234/v1",
 		apiKey: getValue(env, "SURVEY_ASSISTANT_LMSTUDIO_API_KEY")
 	} : void 0;
+	const providerApiKey = provider === "openai" ? getValue(env, "OPENAI_API_KEY") : provider === "mistral" ? getValue(env, "MISTRAL_API_KEY") : provider === "lmstudio" ? getValue(env, "SURVEY_ASSISTANT_LMSTUDIO_API_KEY") : getValue(env, "AZURE_API_KEY");
 	const memoryModelId = getOptionalSameProviderModelId(env, "SURVEY_ASSISTANT_MEMORY_MODEL", modelIdOptions) ?? defaultModelId;
-	const memoryModel = `${provider}/${memoryModelId}`;
+	const memoryModel = provider === "lmstudio" ? {
+		providerId: "lmstudio",
+		modelId: memoryModelId,
+		url: lmstudio.baseUrl,
+		...providerApiKey ? { apiKey: providerApiKey } : {}
+	} : provider === "azure-openai" ? `${provider}/${memoryModelId}` : `${provider}/${memoryModelId}`;
 	const observationalMemory = getBoolean(env, "SURVEY_ASSISTANT_MEMORY_ENABLED", true) ? createSurveyAssistantObservationalMemoryOptions({
 		model: memoryModel,
 		temporalMarkers: getBoolean(env, "SURVEY_ASSISTANT_MEMORY_TEMPORAL_MARKERS", false),
@@ -143,14 +413,22 @@ const parseSurveyAssistantEnvironment = (env, { defaultLmStudioModel, defaultMis
 		reflection: { observationTokens: getPositiveNumber(env, "SURVEY_ASSISTANT_MEMORY_OBSERVATION_TOKENS", SURVEY_ASSISTANT_OBSERVATIONAL_MEMORY_DEFAULTS.observationTokens) }
 	}) : false;
 	const configuredMaxSteps = getPositiveNumber(env, "SURVEY_ASSISTANT_MAX_STEPS", DEFAULT_MAX_STEPS);
-	const enabledSetting = getValue(env, "SURVEY_ASSISTANT_ENABLED")?.toLowerCase();
-	if (enabledSetting !== void 0 && enabledSetting !== "true" && enabledSetting !== "false") throw new Error("SURVEY_ASSISTANT_ENABLED must be \"true\" or \"false\".");
-	const enabled = enabledSetting === "false" ? false : enabledSetting === "true" ? !requireExperimentalIdentityOptIn || env.NODE_ENV === "development" || getBoolean(env, "SURVEY_ASSISTANT_ALLOW_EXPERIMENTAL_IDENTITY", false) : env.NODE_ENV === "development";
+	const enabled = resolveConfiguredEnabled(env, void 0, requireExperimentalIdentityOptIn);
 	return {
 		provider,
 		defaultModelId,
 		memoryModelId,
 		modelIds,
+		models: [...new Set([
+			...modelIds,
+			...taskModelId ? [taskModelId] : [],
+			memoryModelId
+		])].map((id) => ({
+			id,
+			label: id,
+			upstreamModelId: id,
+			providerOptions
+		})),
 		modelCatalogTtlMs: getPositiveNumber(env, "SURVEY_ASSISTANT_MODEL_CATALOG_TTL_MS", DEFAULT_CATALOG_TTL_MS),
 		azure,
 		lmstudio,
@@ -185,18 +463,30 @@ const parseSurveyAssistantEnvironment = (env, { defaultLmStudioModel, defaultMis
 //#endregion
 //#region src/server/runtime.ts
 const createSurveyAssistantModelRouter = (config) => {
+	const configuredModels = new Map(config.models?.map((model) => [model.id, model]));
+	const getConfiguredModel = (modelId) => configuredModels.get(modelId) ?? {
+		id: modelId,
+		label: modelId,
+		upstreamModelId: modelId,
+		providerOptions: config.execution.providerOptions
+	};
 	const toProviderModel = (modelId, configName) => {
+		const upstreamModelId = getConfiguredModel(modelId).upstreamModelId;
 		if (config.provider === "lmstudio") {
 			if (!config.lmstudio) throw new Error("LM Studio configuration is missing for the lmstudio provider.");
 			return {
 				providerId: "lmstudio",
-				modelId,
+				modelId: upstreamModelId,
 				url: config.lmstudio.baseUrl,
 				...config.lmstudio.apiKey ? { apiKey: config.lmstudio.apiKey } : {}
 			};
 		}
-		if (modelId.includes("/")) throw new Error(`${configName} must be a model or deployment id without a provider prefix. All survey assistant models use the configured provider.`);
-		return `${config.provider}/${modelId}`;
+		if (upstreamModelId.includes("/")) throw new Error(`${configName} must be a model or deployment id without a provider prefix. All survey assistant models use the configured provider.`);
+		const id = `${config.provider}/${upstreamModelId}`;
+		return config.providerApiKey && config.provider !== "azure-openai" ? {
+			id,
+			apiKey: config.providerApiKey
+		} : id;
 	};
 	const defaultModel = toProviderModel(config.defaultModelId, "defaultModelId");
 	const chatModelIds = config.modelIds.map((modelId) => {
@@ -207,13 +497,13 @@ const createSurveyAssistantModelRouter = (config) => {
 	const taskModel = config.taskModelId ? toProviderModel(config.taskModelId, "taskModelId") : void 0;
 	const memoryModel = toProviderModel(config.memoryModelId, "memoryModelId");
 	if (config.observationalMemory !== false) {
-		const configuredMemoryModel = `${config.provider}/${config.memoryModelId}`;
-		if (typeof config.observationalMemory.model !== "string" || config.observationalMemory.model !== configuredMemoryModel || config.observationalMemory.observation?.model !== void 0 || config.observationalMemory.reflection?.model !== void 0) throw new Error("The standard runtime requires observationalMemory to use memoryModelId for both observation and reflection. Use the low-level Agent factory for custom memory model routing.");
+		const configuredMemoryModel = toProviderModel(config.memoryModelId, "memoryModelId");
+		if (JSON.stringify(config.observationalMemory.model) !== JSON.stringify(configuredMemoryModel) || config.observationalMemory.observation?.model !== void 0 || config.observationalMemory.reflection?.model !== void 0) throw new Error("The standard runtime requires observationalMemory to use memoryModelId for both observation and reflection. Use the low-level Agent factory for custom memory model routing.");
 	}
 	const deploymentIds = [...new Set([
-		...chatModelIds,
-		...config.taskModelId ? [config.taskModelId] : [],
-		config.memoryModelId
+		...chatModelIds.map((id) => getConfiguredModel(id).upstreamModelId),
+		...config.taskModelId ? [getConfiguredModel(config.taskModelId).upstreamModelId] : [],
+		getConfiguredModel(config.memoryModelId).upstreamModelId
 	])];
 	const azureGateway = config.azure ? new AzureOpenAIGateway({
 		resourceName: config.azure.resourceName ?? "",
@@ -228,14 +518,18 @@ const createSurveyAssistantModelRouter = (config) => {
 		let ids = chatModelIds;
 		if (azureGateway && config.azure?.discoverModels) try {
 			const providers = await azureGateway.fetchProviders();
-			ids = [...new Set([...chatModelIds, ...providers["azure-openai"]?.models ?? []])];
+			const configuredUpstreamIds = new Set(chatModelIds.map((id) => getConfiguredModel(id).upstreamModelId));
+			const discoveredIds = (providers["azure-openai"]?.models ?? []).filter((id) => !configuredUpstreamIds.has(id));
+			ids = [...new Set([...chatModelIds, ...discoveredIds])];
 		} catch {}
 		const value = {
 			defaultModelId: config.defaultModelId,
-			models: ids.map((id) => ({
-				id,
-				label: id
-			}))
+			models: ids.map((id) => {
+				return {
+					id,
+					label: getConfiguredModel(id).label
+				};
+			})
 		};
 		cachedCatalog = {
 			expiresAt: Date.now() + config.modelCatalogTtlMs,
@@ -248,7 +542,9 @@ const createSurveyAssistantModelRouter = (config) => {
 		const id = requestedModelId ?? catalog.defaultModelId;
 		return catalog.models.some((model) => model.id === id) ? {
 			id,
-			model: toProviderModel(id, "requestedModelId")
+			model: toProviderModel(id, "requestedModelId"),
+			providerName: config.provider,
+			...getConfiguredModel(id).providerOptions ? { providerOptions: getConfiguredModel(id).providerOptions } : {}
 		} : null;
 	};
 	return {
@@ -261,7 +557,9 @@ const createSurveyAssistantModelRouter = (config) => {
 		resolveModel: async ({ requestedModelId }) => resolveRequestedModel(requestedModelId),
 		resolveTaskModel: async ({ requestedModelId }) => config.taskModelId ? {
 			id: config.taskModelId,
-			model: taskModel
+			model: taskModel,
+			providerName: config.provider,
+			...getConfiguredModel(config.taskModelId).providerOptions ? { providerOptions: getConfiguredModel(config.taskModelId).providerOptions } : {}
 		} : resolveRequestedModel(requestedModelId),
 		taskModel
 	};
@@ -385,6 +683,6 @@ const createSurveyAssistantRuntime = (config, runtimeOptions = {}) => {
 	};
 };
 //#endregion
-export { createSurveyAssistantModelRouter, createSurveyAssistantRuntime, createSurveyAssistantRuntimeComponents, createSurveyAssistantRuntimeHandlers, parseSurveyAssistantEnvironment, resolveSurveyAssistantProviderOptionsKey };
+export { createSurveyAssistantModelRouter, createSurveyAssistantRuntime, createSurveyAssistantRuntimeComponents, createSurveyAssistantRuntimeHandlers, parseSurveyAssistantConfigurationDocument, parseSurveyAssistantEnvironment, resolveSurveyAssistantProviderOptionsKey, surveyAssistantConfigurationDocumentSchema };
 
 //# sourceMappingURL=server-runtime.mjs.map