windmill-labs/windmill · error

is not supported

Error message

{s} is not supported

What it means

This is the catch-all arm of the Nushell type parser: any type string not in the supported list (string, int, float, number, record, table, nothing, datetime, any, bool, and the few `list<...>` variants) is rejected with `{s} is not supported`. Each unsupported type name is interpolated into the message so you can see exactly which annotation failed.

Solutions

1. Read the interpolated type name in the message and replace it with a supported one: string, int, float, number, bool, any, nothing, record, table, datetime, list, list<any>, list<number>, list<bool>, list<string>.
2. Replace `list<int>`/`list<float>` with `list<number>` or `list` — those element types are explicitly unsupported.
3. Use `any` for types like duration/filesize/range and convert inside the script (`into duration`, etc.).
4. Fix typos in the annotation (`strin:` → `string:`); drop custom type aliases from the deployed signature.
5. Remove `binary` annotations (commented as unsupported) and pass bytes as `any`.

Example fix

// before
def main [wait: duration = 10sec]
// after
def main [wait: any = 10sec] {
  let wait = ($wait | into duration)
}

const SUPPORTED_NU_TYPES = new Set(['string','int','float','number','record','table','nothing','datetime','any','bool','list','list<any>','list<nothing>','list<number>','list<bool>','list<string>']);
function validateNuType(t) {
  const c = t.replace(':', '').trim();
  return SUPPORTED_NU_TYPES.has(c) ? null : `type '${c}' is not supported; use one of string,int,float,number,bool,any,nothing,record,table,datetime,list,list<number>,list<bool>,list<string>`;
}

try {
  const sig = parseNuSignature(source);
} catch (e) {
  const m = String(e).match(/^(.*) is not supported$/s);
  if (m) throw new Error(`Unsupported Nushell type '${m[1]}' in def main — replace with a supported annotation (string/int/float/number/bool/any/record/table/datetime/list...)`);
  throw e;
}

When it happens

Trigger: Using a Nushell type outside the supported set in `def main` — e.g. `duration`, `filesize`, `range`, `closure`, `path`, `binary`, `list<int>`, `list<float>`, `cell-path`, or any custom/typo'd type name.

Common situations: Typos in type names (`strin` instead of `string`); Nushell types added in newer versions (duration, filesize) that the parser predates; `list<int>`/`list<float>` which are explicitly not supported despite lists in general being supported; custom type aliases.

Related errors

• Cannot parse type of argument
• typed records are not supported, use `ident: record`
• typed tables are not supported, use `ident: table`
• Cannot find main function.
• Cannot parse argument ident

AI-assisted analysis of windmill-labs/windmill@e474e8803c (2026-09-03). Data as JSON: /api/errors/f22cedf8623b52ae. Report an issue: GitHub.

Appendix: source

Thrown at backend/parsers/windmill-parser-nu/src/lib.rs:188

            // "binary" => Typ::Bytes,
            "datetime" => Typ::Datetime,
            "any" => Typ::Unknown,
            "bool" => Typ::Bool,
            // Lists
            "list" | "list<any>" | "list<nothing>" => Typ::List(Box::new(Typ::Unknown)),
            "list<number>" => Typ::List(Box::new(Typ::Float)),
            "list<bool>" => Typ::List(Box::new(Typ::Bool)),
            "list<string>" => Typ::List(Box::new(Typ::Str(None))),
            // list<float/int> is not supported
            // Records and Tables
            // TODO: Support in V1?
            s if s.contains("record<") => {
                bail!("typed records are not supported, use `ident: record`")
            }
            s if s.contains("table<") => {
                bail!("typed tables are not supported, use `ident: table`")
            }
            s => bail!("{s} is not supported"),
        };
        Ok(typ)
    }
    fn parse_default(
        content: &str,
        ctx: &[&str],
        i: usize,
        skip: &mut usize,
    ) -> anyhow::Result<Value> {
        let mut c = content.replace("=", "").trim().to_owned();

        fn parse_object_literal(
            (open, close): (char, char),
            mut c_2: String,
            ctx: &[&str],
            i: usize,
            skip: &mut usize,
        ) -> anyhow::Result<String> {

View on GitHub (pinned to e474e8803c)