Nami convierte tus flujos de negocio en APIs ejecutables

Estructura completa del DSL

name: "Nombre de la máquina"

# itemModel: JSON Schema que valida el body de cada ítem
itemModel:
  type: object
  required: [campo1, campo2]
  properties:
    campo1:
      type: string
      minLength: 5
    campo2:
      type: number
      minimum: 0
    imagen:
      type: string        # UUID de archivo
  metadata:
    flags: [activo, procesado]   # flags disponibles
  additionalProperties: true

dsl: |
  map: nombre-del-mapa    # ID único del mapa visual

  nombre-transicion:
    from: estado-a | estado-b    # pipe = múltiples orígenes
    to: estado-destino           # si se omite, usa el nombre
    else: estado-fallback        # opcional: si fallan validadores

    all:                         # AND lógico (o "some:" para OR)
      internal.not_empty:
        - campo1
      internal.compare:
        operator: ">="
        field: campo2
        value: 100
      internal.script: input.item.body.campo2 < 99999

    enter:
      # Exactamente UNO de los tres modos:
      script: "return { resultado: input.item.body.x * 2 }"
      # code: <uuid-del-script-deno>
      # capabilities: [...]

    properties:
      - stop_after_apply    # no encadenar con la siguiente transición

    flags:
      nombre_flag:
        - add_flag1
        - remove_flag2

Ejemplo: Store Credit

name: "Store Credit"

itemModel:
  type: object
  required: [email]
  properties:
    email:
      type: string
      format: email
    balance:
      type: number
      minimum: 0
      maximum: 99999
    amount:
      type: number

dsl: |
  map: store-credit-map

  created:
    from: init
    to: created
    all:
      internal.not_empty: [email]

  add:
    from: created | dim      # viene de "created" O "dim"
    to: add
    all:
      internal.script: >
        input.item.body.amount > 0 &&
        input.item.body.amount <= 99999
    enter:
      script: >
        return {
          balance: input.item.body.balance +
                   input.item.body.amount
        }
    properties:
      - stop_after_apply

  dim:
    from: created | add
    all:
      internal.flag:
        "false": [activo]
    enter:
      script: "return { balance: 0 }"
    flags:
      activo:
        - remove_activo

Reglas de compilación DSL

• from: a | b → múltiples estados origen (pipe-separated)
• to omitido → usa el nombre de la transición
• else → estado al que va si los validadores fallan
• all = AND lógico · some = OR lógico
• enter acepta exactamente uno: script, code o capabilities
• stop_after_apply evita encadenamiento automático de transiciones
• Las transiciones se evalúan en orden; la primera que pasa se aplica
• Sin stop_after_apply, la ejecución continúa en el nuevo estado

Estructura de configuración

enter:
  capabilities:
    - type: generator
      input:
        prompt: "Genera un resumen para: {{brief}}"
        context: "Empresa: {{company_name}}"
        constraints:
          max_words: 100
          language: es
          format: paragraph
      llm:
        model: gemini-2.0-flash      # modelo Gemini
        temperature: 0.5             # 0.0-1.0
        files:                       # adjuntar archivos del body
          - campo_imagen_uuid
          - otro_campo_imagen
      response:
        field: campo_output          # dónde guardar el resultado

Ejemplo: Virtual Try-On con imágenes

name: "Virtual Try-On"

itemModel:
  type: object
  required: [user_file, product_file]
  properties:
    user_file: { type: string }     # UUID de foto del usuario
    product_file: { type: string }  # UUID de foto del producto
    model_response: { type: string }

dsl: |
  map: try-on-map

  start:
    from: init
    to: extract
    all:
      internal.not_empty: [user_file, product_file]
    enter:
      capabilities:
        - type: image_generator
          input:
            text: >
              Virtual try-on: coloca el producto de la
              imagen 2 en el modelo de la imagen 1
            style: "realistic photo"
            resolution: "medium resolution"
          llm:
            model: gemini-3-pro-image-preview
            files:
              - user_file        # adjunta imágenes al LLM
              - product_file
          response:
            field: model_response

Request

POST /api/project-state-machine/{code}/bulk

{
  "script_code": "UUID-DEL-SCRIPT-IMPORTER",
  "additional_info": {
    "api_url": "https://external.api.com/products",
    "api_token": "secret-token",
    "category": "electronics"
  }
}

# Response:
{
  "created_count": 47,
  "error_count": 2,
  "created_items": [
    {
      "code": "uuid",
      "state": "init",
      "body": { "sku": "ABC-123", "name": "...", "price": 99.99 }
    }
  ],
  "errors": [
    { "index": 5, "error": "missing required field: sku" }
  ]
}

Script importer (Deno)

// El script se llama DOS veces:
// 1. Para obtener los datos (operation === 'fetch_data')
// 2. Para transformar cada fila individualmente

const additionalInfo = input.config.additional_info;

// FASE 1: Obtener datos de API externa
if (input.config.operation === 'fetch_data') {
  const response = await fetch(additionalInfo.api_url, {
    headers: {
      'Authorization': `Bearer ${additionalInfo.api_token}`,
      'Content-Type': 'application/json'
    }
  });
  const data = await response.json();

  // Retorna el array de filas a procesar
  return { success: true, result: data.products };
}

// FASE 2: Transformar cada fila
const rawData = input.raw_data;   // fila del array anterior
const index = input.index;         // índice (0-based)

return {
  success: true,
  result: {
    sku: rawData.sku || rawData.id?.toString(),
    name: rawData.name || rawData.title || '',
    price: parseFloat(rawData.price) || 0,
    category: additionalInfo.category,
    external_id: rawData.id?.toString(),
    imported_at: new Date().toISOString()
  }
};

Upload de archivos

POST /api/project-state-machine-items/{code}/files
Content-Type: multipart/form-data
Authorization: Bearer {token}

# Body: multipart con el campo "file"

# Response:
{
  "code": "file-uuid-550e8400...",
  "mimeType": "image/jpeg",
  "size": 204800,
  "createdAt": "2025-01-15T10:30:00Z"
}

# Constraints:
# - Tipos: JPEG, PNG, GIF, WebP, SVG
# - Máx: 100MB por archivo
# - Máx: 10 archivos por ítem

Listar archivos de un ítem

GET /api/project-state-machine-items/{code}/files

Comandos disponibles

Uso típico

# Autenticarse
nami login

# Listar proyectos
nami projects --json

# Desplegar workflow desde archivo DSL
nami deploy workflow.yaml \
  --project /api/projects/{uuid} \
  --name "Mi Workflow v2"

# Generar API token de producción
nami api-key \
  --machine /api/project-state-machines/{code}

# Testear un ítem interactivamente
nami run {item-code}

# Opciones globales:
#   --json          solo output JSON
#   -v              verbose (log cada request/response)
#   --debug-http    debug HTTP completo
#   -k, --insecure  deshabilitar TLS (solo dev)