Argumentos de entrada y salida

Un robot rara vez hace siempre exactamente lo mismo: procesa el mes que le indiques, la sucursal que toque, o el lote que llegó. NORA te deja declarar esos parámetros una sola vez y entonces: el panel te muestra un formulario precargado al lanzar el job, el robot los lee en runtime, y puede devolver resultados de vuelta a NORA.

Es el equivalente a los Input/Output Arguments de UiPath, pero declarados en un único sitio (nora.json) y leídos con el SDK de Python.

flowchart LR
    A["nora.json<br/>inputs / outputs"] -->|nora release push| B["Proceso<br/>(input_schema)"]
    B -->|formulario precargado| C["Lanzar job<br/>(panel / API / cron)"]
    C -->|input_data validado| D["Robot"]
    D -->|sdk.get_input| D
    D -->|sdk.set_output| E["output_data<br/>(visible en el job)"]

1. Declarar los argumentos en nora.json

En el manifiesto del robot añade un bloque inputs (y opcionalmente outputs). Cada argumento lleva nombre, tipo, si es requerido, un valor por defecto y una descripción:

{
  "name": "facturacion-mensual",
  "version": "1.2.0",
  "entry_point": "main.py",
  "inputs": [
    { "name": "mes", "type": "text", "required": true, "description": "Mes a facturar (YYYY-MM)" },
    { "name": "reintentos", "type": "integer", "default": 3, "description": "Reintentos por factura" },
    { "name": "enviar_correo", "type": "bool", "default": true }
  ],
  "outputs": [
    { "name": "facturas_ok", "type": "integer" },
    { "name": "total", "type": "number" }
  ]
}

Tipos soportados: text, integer, number, bool.

Al publicar el release (nora release push), NORA guarda esos argumentos y deriva un JSON Schema que el proceso hereda (input_schema / output_schema). Ese schema es lo que alimenta el formulario del panel y la validación.

Nota

Si no declaras inputs, todo sigue funcionando como antes: el panel muestra un campo de JSON libre y no se valida nada. Declararlos es opcional pero recomendado.

2. El formulario precargado al lanzar

Cuando lanzas el proceso desde Robots Center → Ejecutar, en lugar de un cuadro de JSON crudo, NORA construye un formulario a partir del schema: un campo por argumento, con su tipo (texto, número, casilla), su valor por defecto y marca de obligatorio. Lo mismo aparece al crear una Programación. Siempre puedes alternar a “Editar como JSON” si prefieres pegar el objeto a mano.

sequenceDiagram
    participant U as Operador
    participant N as Robots Center
    participant J as Job
    U->>N: Ejecutar proceso "facturacion-mensual"
    N-->>U: Formulario: mes*, reintentos (3), enviar_correo (✓)
    U->>N: mes = "2026-06"
    N->>N: Valida input_data contra input_schema
    N->>J: Crea el job con input_data

Si el input_data no cumple el schema (falta un requerido, tipo equivocado), NORA responde 422 antes de crear el job, con el detalle del campo que falla.

3. Leer los argumentos en el robot

Dentro del robot, el agente inyecta los argumentos y el SDK los expone. No hay llamada de red: se leen igual que en producción y en nora dev run.

from nora_agent import sdk

mes = sdk.get_input("mes")                       # "2026-06"
reintentos = sdk.get_input("reintentos", 3)      # valor o default si falta
todos = sdk.get_inputs()                          # dict completo: {"mes": ..., ...}

Función	Devuelve
sdk.get_input(name, default=None)	El valor del argumento name (o default si no vino).
sdk.get_input() / sdk.get_inputs()	El dict completo de argumentos.

4. Devolver resultados con set_output

Cuando el robot termina (o durante la ejecución), puede escribir resultados que quedan guardados en el job y visibles en su detalle (Jobs → Salida). Útil para reportar conteos, importes o referencias.

sdk.set_output("facturas_ok", 142)        # una clave
sdk.set_output({"facturas_ok": 142, "total": 18540.50})   # varias a la vez

Las llamadas se mergean sobre output_data, así que puedes reportar de forma incremental. El resultado se ve en el panel y, si encadenas procesos con flujos DAG, se pasa como entrada del siguiente nodo.

5. Probar en local con argumentos

Al depurar desde tu IDE, pásale los argumentos con --input (un JSON) y el robot los leerá con get_input() exactamente como en un job real:

nora dev run main.py --input '{"mes": "2026-06", "reintentos": 5}'

6. Programaciones y triggers con argumentos

• Programaciones (cron): al crear la programación puedes fijar el input_data que se pasará a cada ejecución (ver programaciones).
• Webhook / trigger: el payload entrante se fusiona con la plantilla del trigger y se pasa como input_data, validado contra el schema del proceso (ver webhooks).
• API: POST /api/v1/jobs/trigger acepta input_data (ver disparar jobs).

Resumen

Paso	Dónde	Qué
Declarar	nora.json (inputs/outputs)	nombre, tipo, requerido, default, descripción
Publicar	nora release push	deriva input_schema/output_schema
Lanzar	Panel / cron / webhook / API	formulario precargado + validación
Leer	Robot	sdk.get_input() / get_inputs()
Devolver	Robot	sdk.set_output() → visible en el job

Referencia rápida de todas las funciones en la lámina de comandos.