description: string | null | undefined,

name?: string

): boolean {

if (!description) return true

const normalizedDesc = description.toLowerCase().trim()

return (

description === name ||

normalizedDesc === 'new workflow' ||

normalizedDesc === 'your first workflow - start building here!'

)

workflowId: string,

executionContext: WorkflowToolExecutionContext | undefined

): Promise<{ name: string; description: string | null } | null> {

try {

if (!executionContext?.userId) {

throw new Error('Workflow metadata enrichment requires a trusted execution subject')

}

const { buildAPIUrl, buildExecutorDelegationHeaders } = await import('@/executor/utils/http')

const { executionScopeForTarget } = await import('@/executor/utils/delegation')

const headers = await buildExecutorDelegationHeaders({

subjectUserId: executionContext.userId,

workflowId,

...executionScopeForTarget(executionContext, workflowId),

})

const url = buildAPIUrl(`/api/workflows/${workflowId}`)

const response = await fetch(url.toString(), { headers })

if (!response.ok) {

await response.text().catch(() => {})

logger.warn(`Failed to fetch workflow metadata for ${workflowId}`)

return null

}

const { data } = await response.json()

return {

name: data?.name || 'Workflow',

description: data?.description || null,

}

} catch (error) {

logger.error('Error fetching workflow metadata:', error)

return null

}

id: string

name: string

description: string

version: string

models: string[]

defaultModel: string

computerUseModels?: string[]

modelPatterns?: RegExp[]

const def = PROVIDER_DEFINITIONS[providerId]

return {

id: providerId,

name: def?.name || providerId,

description: def?.description || '',

version: '1.0.0',

models: getProviderModelsFromDefinitions(providerId),

defaultModel: getProviderDefaultModelFromDefinitions(providerId),

modelPatterns: def?.modelPatterns,

}

const { updateVLLMModels } = require('@/providers/models')

updateVLLMModels(models)

providers.vllm.models = getProviderModelsFromDefinitions('vllm')

const { updateLiteLLMModels } = require('@/providers/models')

updateLiteLLMModels(models)

providers.litellm.models = getProviderModelsFromDefinitions('litellm')

const { updateOpenRouterModels } = await import('@/providers/models')

updateOpenRouterModels(models)

providers.openrouter.models = getProviderModelsFromDefinitions('openrouter')

const { updateFireworksModels } = await import('@/providers/models')

updateFireworksModels(models)

providers.fireworks.models = getProviderModelsFromDefinitions('fireworks')

const { updateOllamaCloudModels } = await import('@/providers/models')

updateOllamaCloudModels(models)

providers['ollama-cloud'].models = getProviderModelsFromDefinitions('ollama-cloud')

const { updateTogetherModels } = await import('@/providers/models')

updateTogetherModels(models)

providers.together.models = getProviderModelsFromDefinitions('together')

const { updateBasetenModels } = await import('@/providers/models')

updateBasetenModels(models)

providers.baseten.models = getProviderModelsFromDefinitions('baseten')

const allProviders = Object.entries(providers)

.filter(

([providerId]) =>

providerId !== 'ollama' &&

providerId !== 'ollama-cloud' &&

providerId !== 'vllm' &&

providerId !== 'litellm' &&

providerId !== 'openrouter' &&

providerId !== 'fireworks' &&

providerId !== 'together' &&

providerId !== 'baseten'

)

.reduce(

(map, [providerId, config]) => {

config.models.forEach((model) => {

map[model.toLowerCase()] = providerId as ProviderId

})

return map

},

{} as Record<string, ProviderId>

)

return filterBlacklistedModelsFromProviderMap(allProviders)

providerMap: Record<string, ProviderId>

): Record<string, ProviderId> {

const filtered: Record<string, ProviderId> = {}

for (const [model, providerId] of Object.entries(providerMap)) {

if (isProviderBlacklisted(providerId)) {

continue

}

if (!isModelBlacklisted(model)) {

filtered[model] = providerId

}

}

return filtered

return Object.entries(providers).reduce(

(map, [providerId, config]) => {

config.models.forEach((model) => {

map[model.toLowerCase()] = providerId as ProviderId

})

return map

},

{} as Record<string, ProviderId>

)

const normalizedModel = model.toLowerCase()

const declared = getAllModelProviders()[normalizedModel]

if (declared) return declared

for (const [id, config] of Object.entries(providers)) {

for (const pattern of config.modelPatterns ?? []) {

if (pattern.test(normalizedModel)) return id as ProviderId

}

}

return null

const normalizedModel = model.toLowerCase()

let providerId = findProviderFromModel(model)

if (!providerId) {

logger.warn(`No provider found for model: ${model}, defaulting to ollama`)

providerId = 'ollama'

}

if (isProviderBlacklisted(providerId)) {

throw new Error(`Provider "${providerId}" is not available`)

}

if (isModelBlacklisted(normalizedModel)) {

throw new Error(`Model "${model}" is not available`)

}

return providerId

if (!env.BLACKLISTED_MODELS) return { models: [], prefixes: [] }

const entries = env.BLACKLISTED_MODELS.split(',').map((m) => m.trim().toLowerCase())

const models = entries.filter((e) => !e.endsWith('*'))

const prefixes = entries.filter((e) => e.endsWith('*')).map((e) => e.slice(0, -1))

return { models, prefixes }

const lowerModel = model.toLowerCase()

const blacklist = getBlacklistedModels()

if (blacklist.models.includes(lowerModel)) {

return true

}

if (blacklist.prefixes.some((prefix) => lowerModel.startsWith(prefix))) {

return true

}

return false

const name = schemaName || 'response'

return `IMPORTANT: You must respond with a valid JSON object that conforms to the following schema.

if (!responseFormat) return ''

if (responseFormat.schema || (responseFormat.type === 'object' && responseFormat.properties)) {

return ''

}

if (!responseFormat.fields) return ''

function generateFieldStructure(field: any): string {

if (field.type === 'object' && field.properties) {

return `{

}

return field.type === 'string'

? '"value"'

: field.type === 'number'

? '0'

: field.type === 'boolean'

? 'true/false'

: '[]'

}

const exampleFormat = responseFormat.fields

.map((field: any) => ` "${field.name}": ${generateFieldStructure(field)}`)

.join(',\n')

const fieldDescriptions = responseFormat.fields

.map((field: any) => {

let desc = `${field.name} (${field.type})`

if (field.description) desc += `: ${field.description}`

if (field.type === 'object' && field.properties) {

desc += '\nProperties:'

Object.entries(field.properties).forEach(([key, prop]: [string, any]) => {

desc += `\n - ${key} (${(prop as any).type}): ${(prop as any).description || ''}`

})

}

return desc

})

.join('\n')

return `

const trimmed = content.trim()

const firstBrace = trimmed.indexOf('{')

const lastBrace = trimmed.lastIndexOf('}')

if (firstBrace === -1 || lastBrace === -1) {

throw new Error('No JSON object found in content')

}

const jsonStr = trimmed.slice(firstBrace, lastBrace + 1)

try {

return JSON.parse(jsonStr)

} catch (_error) {

const cleaned = jsonStr

.replace(/\n/g, ' ')

.replace(/\s+/g, ' ')

.replace(/,\s*([}\]])/g, '$1')

try {

return JSON.parse(cleaned)

} catch (innerError) {

logger.error('Failed to parse JSON response', {

contentLength: content.length,

extractedLength: jsonStr.length,

cleanedLength: cleaned.length,

error: getErrorMessage(innerError, 'Unknown error'),

})

throw new Error(

`Failed to parse JSON after cleanup: ${getErrorMessage(innerError, 'Unknown error')}`

)

}

}

params: Record<string, any>,

canonicalGroups: CanonicalGroup[],

scopedCanonicalModes?: CanonicalModeOverrides

): Record<string, any> {

if (canonicalGroups.length === 0) return params

const resolved = { ...params }

for (const group of canonicalGroups) {

// Route through the canonical SOT: an explicit scoped override wins, else the value heuristic -

// no `?? 'basic'` (which ignored an advanced-only value when basic was empty).

const explicitMode = scopedCanonicalModes?.[group.canonicalId]

const chosen = resolveActiveCanonicalValue(

group,

params,

explicitMode ? { [group.canonicalId]: explicitMode } : undefined

)

if (chosen !== undefined) resolved[group.canonicalId] = chosen

}

return resolved

switch (fieldType) {

case 'number':

return 'number'

case 'boolean':

return 'boolean'

case 'object':

return 'object'

case 'array':

return 'array'

default:

return 'string'

}

blockName: string,

inputFields: WorkflowInputField[],

requiredInputIds: string[]

): ProviderToolConfig['parameters'] {

const requiredSet = new Set(requiredInputIds)

const properties: Record<string, any> = {}

const requiredFields: string[] = []

for (const field of inputFields) {

if (isFileFieldType(field.type)) continue

const key = field.id ?? field.name

properties[key] = {

type: inputFieldSchemaType(field.type),

description: field.description ? `${field.name} — ${field.description}` : field.name,

}

if (requiredSet.has(key)) requiredFields.push(key)

}

return {

type: 'object',

properties: {

inputMapping: {

type: 'object',

description: `Input values for ${blockName}`,

properties,

required: requiredFields,

},

},

required: requiredFields.length > 0 ? ['inputMapping'] : [],

}

blockedParams: string[] | undefined,

llmArgs: Record<string, any>

): Record<string, any> {

if (!blockedParams?.length) return llmArgs

const blocked = new Set(blockedParams)

const filtered: Record<string, any> = {}

for (const [key, value] of Object.entries(llmArgs)) {

if (!blocked.has(key)) filtered[key] = value

}

return filtered

let value = raw

if (typeof value === 'string') {

try {

value = JSON.parse(value)

} catch {

// A bare name rather than a list — treat it as a single entry.

return value ? [value as string] : []

}

}

return Array.isArray(value)

? value.filter((name): name is string => typeof name === 'string' && name.length > 0)

: []

block: any,

options: {

selectedOperation?: string

getAllBlocks: () => any[]

getTool: (toolId: string) => any

getToolAsync?: (toolId: string) => Promise<any>

canonicalModes?: Record<string, 'basic' | 'advanced'>

enrichmentContext?: WorkflowToolExecutionContext

/**

resolveCustomBlockBinding?: (blockType: string) => Promise<CustomBlockToolBinding | null>

/**

toolIndex?: number

}

): Promise<ProviderToolConfig | null> {

const {

selectedOperation,

getAllBlocks,

getTool,

getToolAsync,

canonicalModes,

enrichmentContext,

toolIndex,

} = options

const scopedCanonicalModes = scopeCanonicalModesForTool(canonicalModes, toolIndex, block.type)

const blockDef = getAllBlocks().find((b: any) => b.type === block.type)

if (!blockDef) {

logger.warn(`Block definition not found for type: ${block.type}`)

return null

}

// Custom (deploy-as-block) blocks resolve to the generic `workflow_executor`, but

// as an agent tool they must run through the authority boundary (owner identity,

// latest deployment, curated outputs) — not the plain workflow executor. Route

// them to the dedicated in-process `deployed_block_executor` tool, carrying the

// block TYPE (never a source workflow id) so authority is re-resolved server-side.

// Dynamic imports keep the DB/executor dependency graph out of client bundles.

if (isCustomBlockType(block.type)) {

const binding = await options.resolveCustomBlockBinding?.(block.type)

if (!binding) {

logger.warn(`Custom block tool binding not resolved for type: ${block.type}`)

return null

}

const customToolConfig = getTool('deployed_block_executor')

if (!customToolConfig) {

logger.warn('deployed_block_executor tool not registered')

return null

}

const inputMapping = assembleCustomBlockInputMapping(block.params || {})

// A `file[]` field is omitted from the model schema (the model can't synthesize

// upload descriptors). If such a field is REQUIRED and the user hasn't

// pre-filled it on the block, no invocation could ever satisfy the child's

// required-input check — so don't offer an unusable tool at all.

const prefilled = JSON.parse(inputMapping) as Record<string, unknown>

const requiredIds = new Set(binding.requiredInputIds)

const unfillableFileField = binding.inputFields.find((field) => {

const key = field.id ?? field.name

return isFileFieldType(field.type) && requiredIds.has(key) && !(key in prefilled)

})

if (unfillableFileField) {

logger.warn(

`Custom block ${block.type} not offered as a tool: required file input "${unfillableFileField.name}" has no preset value and cannot be supplied by the model`

)

return null

}

return {

// Unique per block so two custom-block tools never collide on the wire.

id: `deployed_block_executor_${block.type}`,

// Name/description come from the block itself — never the source workflow's

// metadata, which the consumer has no access to.

name: blockDef.name,

description: blockDef.description || customToolConfig.description,

params: {

blockType: block.type,

inputMapping,

},

parameters: buildCustomBlockInputMappingSchema(

blockDef.name,

binding.inputFields,

binding.requiredInputIds

),

}

}

let toolId: string | null = null

if ((blockDef.tools?.access?.length || 0) > 1) {

if (selectedOperation && blockDef.tools?.config?.tool) {

try {

toolId = blockDef.tools.config.tool({

...block.params,

operation: selectedOperation,

})

} catch (error) {

logger.error('Error selecting tool for block', {

blockType: block.type,

operation: selectedOperation,

error,

})

return null

}

} else {

toolId = blockDef.tools.access[0]

}

} else {

toolId = blockDef.tools?.access?.[0] || null

}

if (!toolId) {

logger.warn(`No tool ID found for block: ${block.type}`)

return null

}

let toolConfig: any

if (isCustomTool(toolId) && getToolAsync) {

toolConfig = await getToolAsync(toolId)

} else {

toolConfig = getTool(toolId)

}

if (!toolConfig) {

logger.warn(`Tool config not found for ID: ${toolId}`)

return null

}

const { createLLMToolSchema } = await import('@/tools/params')

const userProvidedParams = block.params || {}

const canonicalGroups: CanonicalGroup[] = blockDef?.subBlocks

? Object.values(buildCanonicalIndex(blockDef.subBlocks).groupsById).filter(isCanonicalPair)

: []

const resolvedResourceParams = resolveCanonicalResourceParams(

userProvidedParams,

canonicalGroups,

scopedCanonicalModes

)

const {

schema: llmSchema,

enrichedDescription,

modelBlockedParams,

} = await createLLMToolSchema(toolConfig, resolvedResourceParams, enrichmentContext)

let uniqueToolId = toolConfig.id

let toolName = toolConfig.name

let toolDescription = enrichedDescription || toolConfig.description

if (toolId === 'workflow_executor' && resolvedResourceParams.workflowId) {

uniqueToolId = `${toolConfig.id}_${resolvedResourceParams.workflowId}`

const workflowMetadata = await fetchWorkflowMetadata(

resolvedResourceParams.workflowId,

enrichmentContext

)

if (workflowMetadata) {

toolName = workflowMetadata.name || toolConfig.name

if (

workflowMetadata.description &&

!isDefaultWorkflowDescription(workflowMetadata.description, workflowMetadata.name)

) {

toolDescription = workflowMetadata.description

}

}

} else if (toolId === 'function_execute' && resolvedResourceParams.secretScope === 'selected') {

// Scoping alone would leave the model guessing: the secrets are injected

// server-side and nothing else advertises them. Names only — values never

// enter the provider request, matching the copilot's workspace-context rule.

// `StoredTool.params` holds strings, so a multi-select arrives JSON-encoded;

// the executor's paramsTransform parses it later, but this runs before that.

const mounted = readMountedSecretNames(resolvedResourceParams.mountedSecrets)

toolDescription = mounted.length

? `${toolDescription}\n\nWorkspace secret names available to this code: ${mounted.join(', ')}. Reference one with the exact {{NAME}} syntax. Its value is bound only while the code executes and is not included in the model request. No other secrets are readable.`

: `${toolDescription}\n\nThis code has no access to workspace secrets.`

} else if (toolId.startsWith('knowledge_') && resolvedResourceParams.knowledgeBaseId) {

uniqueToolId = `${toolConfig.id}_${resolvedResourceParams.knowledgeBaseId}`

} else if (toolId.startsWith('table_') && resolvedResourceParams.tableId) {

uniqueToolId = `${toolConfig.id}_${resolvedResourceParams.tableId}`

}

const blockParamsFn = blockDef?.tools?.config?.params as

| ((p: Record<string, any>) => Record<string, any>)

| undefined

const blockInputDefs = blockDef?.inputs as Record<string, any> | undefined

const needsTransform = blockParamsFn || blockInputDefs || canonicalGroups.length > 0

const paramsTransform = needsTransform

? (params: Record<string, any>): Record<string, any> => {

let result = { ...params }

for (const group of canonicalGroups) {

// Route through the canonical SOT: an explicit scoped override wins, else the value

// heuristic - no `?? 'basic'` (which dropped an advanced-only value when basic was empty).

const explicitMode = scopedCanonicalModes?.[group.canonicalId]

const chosen = resolveActiveCanonicalValue(

group,

result,

explicitMode ? { [group.canonicalId]: explicitMode } : undefined

)

const sourceIds = [group.basicId, ...group.advancedIds].filter(Boolean) as string[]

result = omit(result, sourceIds)

if (chosen !== undefined) {

result[group.canonicalId] = chosen